Significance Of Component Base Architecture

572 views
514 views

Published on

Significance Of Component Base Architecture

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
572
On SlideShare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
5
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Significance Of Component Base Architecture

  1. 1. Significance Of Component Base Architecture & Xwiki Application Architecture. By Chathura Prabuddha Ganegoda. http://gacpganegoda.blogspot.com/ http://www.xwiki.org/xwiki/bin/view/X Wiki/ChathuraPrabuddha
  2. 2. Topics • Advantage of Component Base Architecture. • Plexus. • Application Development Architecture in Xwiki. • Useful things you can practice.
  3. 3. Advantage of Component Base Architecture • Separation of Concerns • Easier to apply common design patterns • Components are easier to construct and configure. • Components are easier to manage. • Components are implicitly easier to unit test. • Components facilitate advanced application architecture without modifying code.
  4. 4. Separation of Concerns • It is a design pattern that encourages each individual part of a system to have a clear concern (which may also be referred to as a role or function). • The boundaries between these parts should also be clear and well defined. • Using components will help you in applying separation of concerns to your design.
  5. 5. Easier to apply common design patterns • While separation of concerns is the most significant design pattern to appear in a component-oriented design, the use of container functionality can facilitate other design patterns in a simple, consistent manner.
  6. 6. Components are easier to construct and configure. • There will be a number of fields in the components that will need to be populated. Features in containers such as Plexus aid in the construction of your objects, making it faster to develop than before, with less code. • So, a component may declare its default configuration, but include an expression that is able to obtain information from the system using it to populate it at runtime, without needing to know anything about the target application at design time. The target application may override the configuration entirely based on its own needs, or even based on other runtime environment factors.
  7. 7. Components are easier to manage. • Not only are components easier to construct, but in a good component container such as Plexus they will also be easier to manage through their life within the application. • In Java, you only have control over construction (calling the constructor) and calling methods on the object (or modifying fields). Other behaviour such as finalization is not called predictably and can not be used to perform object clean up, for example. • In containers that support component lifecycles, such as Plexus, the component author has control over all aspects of a component's lifecycle. For example, the component can be consulted when the component has been initialized, started, stopped, or destroyed to name a few. In Plexus, not only can the components participate in the lifecycle, but a component's lifecycle can be completely customised. • The ability to participate in the component lifecycle can enable the component author to perform necessary set up and clean up, and also to easily apply some design patterns to a component without having to recode the component state handling.
  8. 8. Components are implicitly easier to unit test. • When testing code, it is usualy expected that it is tested in isolation, so that the tests are not influenced by external factors and so that the tests are simpler and easier to write. Through separation of concerns, this becomes a reality. • In addition, since component construction and configuration can be altered, it is easy to replace default implementations of other components with simple mocks or stubs that guarantee that you are testing a single component at a time. • Tests generally require quite a lot of object configuration, much of which is duplicated for all but one or two values. Using a component container can dramatically ease this through having pre-set configurations that are modified on a per-test basis. • Finally, since component tests can be run inside the container, the lifecycle of the component can be executed as it would in the real system, without needing to construct the calling objects. This again makes it easier to test a component in isolation.
  9. 9. Components facilitate advanced application architecture without modifying code. • Clear separation of components, along with well-defined interfaces, allow replacing components with other implementations. This can facilitate advanced application architectures without code modifications.
  10. 10. Plexus Based on the Plexus container, the applications can utilise component- oriented programming to build modular, reusable components that can easily be assembled and reused. While Plexus is similar to other inversion-of-control (IoC) or dependency injection frameworks such as the Spring Framework, it is a full-fledged container that supports many more features such as: • Component lifecycles • Component instantiation strategies • Nested containers • Component configuration • Auto-wiring • Component dependencies, and Various dependency injection techniques including constructor injection, setter injection, and private field injection.
  11. 11. Application Development Architecture in Xwiki. • Understanding through Mockups. • Data Model. (Explained based on the diagrams.)
  12. 12. Useful Things you can practice. • Maintain a blog like thing in teamwork oneteam site to put the solutions you have figure out during the development. • Two Techboost session for a week.(Each one will share their experience and what they learned) • Maintain a common chat application where all the developers are online in one place. (This must only use for exchange technological things.)
  13. 13. Thank you. Special Thanks to • Java Team. • Inoka & Parani.

×