Significance Of Component Base Architecture

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. Topics
• Advantage of Component Base Architecture.
• Plexus.
• Application Development Architecture in Xwiki.
• Useful things you can practice.

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. 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. 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. 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. 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. 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. 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. 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. Application Development Architecture in
Xwiki.
• Understanding through Mockups.
• Data Model.
(Explained based on the diagrams.)

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. Thank you.
Special Thanks to
• Java Team.
• Inoka & Parani.