Component Based Architecture

Objectives

Introduce notions of Software ComponentDiscuss Pros and Cons

IntroductionComponent-based Architecture used to

Divide a problem into sub-problems Each sub-problem is associated with a componentInterface plays an important role

MotivationComponents are highly reusableA component encapsulates the functionality and behaviors of a software element into a reusable and self-deployable binary.Use of COTS or developed in-house componentsIncreases overall reliability

Can greatly reduce development cost

Components Important points

A component is a deployable software package that can provide services to its clientIt may require services from other componentsIt remains self-contained and substitutable as long as it interface is unchanged.

Components Vs. OO designA component-oriented represents a higher level of abstraction than an equivalent OO design

The component-oriented design defines components and connections between them instead of classes and connections between classes

In component-oriented designFirst identify all components and their interfaces

Advantages over OO designReduced time in marketLower development costs by reuse of the existing components, and increased reliability with reuse of the existing components

Component ExamplesMany standard component frameworks

COM/DCOMJavaBeanEJBCORBA.NetWeb ServicesGrid Services

What is ComponentA component is a modular (cohesive), deployable (portable), replaceable (plug-and –play), and reusable set of well-defined functionalities that encapsulates its implementation and exports it as a higher-level interface.

Component

• It is called as provided port

• Services the component provides

• Supported Interface

• It is called as required port

• Services the component requires

• Supported Interface

Ports may be connected synchronously or asynchronously or via I/O streams

ExampleA UML component can be mapped to any target technology componentExamples:

EBJ Component (.jar file)Java Web Component (.war file)What about MS .Net Component? .dll file

Why use components?ReusabilityProductivityComposabilityAdaptibilityScalabilityReliability and many others

Component ImplementationUsually consists of a set of class files

Abstract InterfaceConcrete Implementation Classes

Note:Some IDE tools support visualization of components, e.g., VS Studio .Net ToolsetHowever, it does not mean that each component should have such a visual representation

Java Example: Java Counter

package counter;

interface Counter { public void setCount(int c); public int getCount(); public void inc();}

Java Example: Implementation File

import counter.*;class CouterImpl implements Counter { private int count; public void setCount(int c){ count = c;} public int getCount(){ return count;} public void inc() { count ++; } }

Why Interface & Implementation?

Separation of Interface and Implementation allows changeability!

Example 1: CounterImpl1 myCounter = new CounterImpl1();myCounter.inc();

Example 2:CounterImpl2 myCounter = new CounterImpl2();

Principles of Component-Based ArchitectureFigure out semantics of connections

Communication semantics important Local: relatively easy Remote: pay attention! many different call semantics

Think about INTERFACE, not the implementation

Component Level DesignBefore the design phase, we have

Use case modelingBusiness concept modeling

Use case diagrams Describes user interactions with the system which indicate all

necessary operations of the componentWe can map use case diagram to the provided service interfaces of the first-cut component specification

Component Level DesignA collaboration diagram

is an identifiable slice of functionality that describes a meaningful service involving several concepts.

A collaboration diagram the implementation of a use case

For each use case U, there will be a collaboration diagram “encapsulated” in a component C.

Component Level DesignUse case component implementation

Component Level DesignBusiness concept diagram

Depicts the relationships of the business process entities in the domain

Extract business process entities that can exist independently without any associated dependency on other entities.

Recognize and discover these independent entities as new components.

Component Level DesignStarts from Use Case Diagram

May also need business concept diagram

MappingUse case interface providerconceptual classes modules of componentsIf necessary, big components can be further decomposed

Example: Doctor Appt. SystemA clinic has dozen family doctorsEach doctor has a schedule with slots of 15 minutespatients can make appointmentpatients can change and cancel appointmentNew patients are welcomedoctor can mark off slotspatients and doctors can display schedules on computer at any time

Use Case Diagram

patient

doctor

makeappointment

change or cancelappointment

display appointment

make schedule

Business Concepts Diagram

doctor

schedule patient

daily appointment

billing

1

1 1

**

1

1

n

Domain entities and business concept

Identification of Components and Types

<<interface>>IDMGT

<< core >>doctor

<< core >>patient

<< Interface >>IPtMGT

<< type >>Schedule

<< type >>daily appointment

1 1

1

*

* *

Assume no class diagram available

Doctor and patients can exist alone without any dependency

The UML notation for interface or core type is << >>

The core type can exist independently

Each core type has management interface

A schedule belongs to doctor and is derived from appointments

Daily appointments are derived from doctor-patient schedule

Derived, so cannot exist independently

Component Design

<< comp >>

billing

<< comp >>

<< comp >>

patient management

doctor management

<< comp spec >>

clinic

appointment

system

make appointment

update appointment

update schedule

Summary - CBA

Applicable domain Suitable for where the interface contracts between sub-systems are clear.Suitable for loose coupling between the components and many reusable components are availableSuitable for the class library system organization. .NET class library and Java API themselves are built in component architecture

Summary - CBABenefits:

Reusability of components: System maintenance and evolution: Independency and flexible connectivity of componentsProductivity Many OO design tools available

Limitations:Sometime it is difficult to find suitable components to reuse.Adaptation of components is always an issue.