Component Based Architecture
description
Transcript of Component Based Architecture
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.