Processes for Architecting - A White Paper
By Palash Ghosh
Abstract
This paper defines the process of architecting
and brings out the best practices for architecting
a Java/J2EE solution with a real FileNet-based
project example.
It dwells deep into the concepts of layered and
component-based architecture and provides
detailed explanations, guidelines and benefits
associated with creating enterprise architecture.
Introduction
The popular consensus is that a good architect
does not necessarily have to be a good
programmer. But I do not agree with this. I
believe that one has to go through the process
of getting her/his hands dirty and work on the
nitty gritties of programming and other
development related activities before s(he) will
have gained enough knowledge and experience
to conceptualize and create an enterprise-level
architecture that is innovative and practical.
Today’s business situation is information driven,
with technology being one of the key business
enabler and in some cases, a business driver.
The whole world is talking about enterprise
solutions and enterprise applications.
What is an enterprise solution?
We could define an enterprise solution as a
technology solution that enables organization-
wide problems to be addressed seamlessly by
technology. In the past, technology solutions
usage was very departmentalized with different
departments in an organization following
different technology philosophies and strategies.
As technology advanced and grew sophisticated
enough to accommodate and address
enterprise-wide problems, the decentralized ,
departmental approach followed by companies
led to various problems that affected the very
efficiency and productivity of companies, putting
pressure on them to sustain themselves in a
competitive, ever-changing market.
Challenges in today’s business scenario –
• Business logic is getting very complex and
agile in nature
• Integration points with different businesses
running on different technology platforms
• Scalability and maintainability
• Security Issues
• Performance
To address these challenges, organizations
today need to build reliable, robust, agile
solutions that incorporate a scalable and
extensible architecture.
In order to successfully architect Java/J2EE
solutions, an architect needs to have a thorough
understanding of the following:
• Methodology (RUP etc)
• UML
• Best Practices (Java/J2EE Design Pattern)
• Technology (Java/2EE)
There are different architectural views (Process
View, Logical View etc) through which an
architecture can be represented. I believe that
the logical view and the physical (deployment)
views are the most important architectural
representations.
4 + 1 Architecture View Model
The 4 + 1 View Model describes software
architecture using five concurrent views, each of
which addresses a specific set of concerns:
• The logical view, which is the object model
of the design (when an object-oriented
design methodology is used)
• The process view, which captures the
concurrency and synchronization aspects of
the design
• The physical view, which describes the
mapping(s) of the software onto the
hardware and reflects its distributed aspect
• The implementation view, which describes
the static organization of the software in its
development environment
The description of the architecture and the
decisions made can be organized around these
four views, and then illustrated by a few
selected use cases, or scenarios, which becomes
the fifth view.
In cricket there is a strategy - ‘Play session by
session’ so that you can change the pace of the
game accordingly. The same analogy can be
used in software architecting for a given
requirement - do not think about the solution as
one big whole; rather, start thinking about the
different building blocks/components of the
solution and think about how the different
components can communicate with each other.
This building-block approach will lead to a
reliable logical view of the architecture.
Today’s business needs demands an
architecture that is scalable, maintainable,
component based and layered and on top of
that it should be enough flexible to adapt any
change. So, while embarking on a software
architecture journey, a big picture approach
should be taken and the key elements of the
design should be of primary importance. Paying
too much attention to minute details and issues
right at the beginning will not have the desired
results. The design process will rationalize itself
and the final architecture will address all the
issues.
general belief is that most packaged
solutions/products contain multiple out-of-the-
box features and therefore there is no need for
these products be fit into a design framework
while they are deployed to address enterprise-
wide needs. The fact is that, thought these
products have a lot of out-of-the-box features,
there still is a great amount of customization
that is required in order to build a solution that
addresses a customer’s specific needs.
Therefore, these products need to fit into an
enterprise architecture, in order to perform
effectively. This is where technology comes into
the picture. In most customized solutions built
on top of Document Management/Workflow
products, the product is primarily used as a
document repository and to some extent helps
in automating business processes with the help
of the API that comes with these products used
But to build a holistic solution that addresses all
the customer needs and provides a wide range
of functionalities, while taking into account
integration, administration and security needs,
the product based solution has to be customized
to a greater extent. For this to happen, an
architectural framework has to be created that
will accommodate the product as well as
address solution functionalities that the product
does not address.

In a product development scenario, the

mindset and the approach is very different to
an IT services model that where there is never
enough time to perform all design activities
that a typical product development
exercise would require.
In most IT services situations, there is a need to
deliver a quality product in a very short period
of time and that is the biggest challenge. This is
where framework development comes into the
picture to sufficiently address the cost and time
constraints.

I would like to take an example of a Document

Management/Workflow product based solution
that was developed for a global insurance
customer. The product used was FileNet. The
Let me share my experience as a technical
architect, building a customized solution for a
global insurance customer. The solution was
primarily a document management and
workflow solution.
The logical view of the architecture is given
below
FileNet’s eProcess workflow product, along with
Image Services Resource Adapter (ISRA) was
used as the basis of this solution. eProcess has
two sets of Java API – one is for accessing the
documents in the repository and the other for
mainly managing the workflows. From a
Java/J2EE application there was a need to
access third-party API that may undergo
changes and modifications in course of time. So,
it was decided to introduce two adapters in the
architecture for two sets of API exposed by
FileNET.
This adapter layer exposes its high level
interfaces only, so that at a later time, if
changes in the API take place in the
implementation classes, the other components
where the methods of the interfaces are used
do not need to undergo any change.
Benefits of this approach are:
• The Adapter layer encapsulates and provides
a business level interface of Workflow APIs
to the core services in the Business Services
layer.
• The set of APIs provided by workflow would
be accessed sitting in this layer to make the
application easily maintainable.
The horizontal layer includes all the
infrastructure related components, which are
used across the whole spectrum of the solution.
Next let us look into infrastructure components.
Any Java/J2EE solution must have very good
logging as well as a very robust exception
handling strategy, which needs to be i18n
enabled (internationalization). A robust
mechanism has to be built in which helps to
pass the proper exception across the different
layers and display a customized error message
to the user, which has to be i18n enabled too.
This exception handling strategy provides a
base mechanism and guideline for handling
exceptions arising out of business conditions,
and errors arising out of non-business and
system-specific erroneous conditions.
The component will provide the following
facilities:
• Implement exception and error handling
• Support for internationalization
• Log exception messages depending on the
exception severity
• Decide whether an error message should be
shown to the user, or to log an exception
message
• Framework to support storing the error
messages in property files
• Framework to support handling of the return
codes
An Exception can be classified by logging
severity level. The framework supports the
following severity levels:
• Debug
• Info
• Warn
• Error
The Framework provides a loose coupling of
error messages. Every error or exception is
referred by a unique identifier know as errorID.
Only errorID shall be used in the application
code base. For each errorID, there exists a
corresponding error message, which is displayed
to the end-user. Since the error messages need
to be shown in the language according the end
user’s preference or profile, they are maintained
in each language variant.
The framework will support Resource Bundle for
persisting the error messages, i18n java
internationalization features are being used to
store and retrieve the error messages based on
an end-user profile.
There is a Base Exception Class for the whole
application. And each layer has its own
exception, which extends from Base Exception.
The corresponding exception would be thrown
from the related layer and would be caught in
the next layer of the hierarchy.
Now, lets talk about the Logger. The Logger is
a subsystem that represents an enterprise
logging mechanism for distributed applications.
This component will expose methods which will
help the system to log the messages in text file
depending on their available severity level as
info, warn, debug, error. With Apache log4j it is
possible to enable logging at runtime without
modifying the application binary. The log4j
package is designed so that these statements
can remain in shipped code without incurring a
heavy performance cost. Editing a configuration
file, without touching the application binary, can
control logging behavior. A wrapper over Log4j
(an Apache open source framework already
available) was built for Logger, which is a
standard practice.
The requirements also demanded an
integration layer to integrate with an Oracle
database and MQ Series. For the database
integration DAO and DAO Factory were used,
which is a very standard approach, suggested
by J2EE pattern. By using these patterns, the
database/SQL related code will reside in the
same place, which will help maintain the code
and more importantly, the database can be
ported from Oracle to SQL Server or DB2
without much difficulty and without having to
modify application logic.
There is a need in layered architecture to
transfer data across the layer in terms of Data
Transfer Object. Care needs to be taken to
determine when the data can be changed and
when it needs to be immutable. This is a very
crucial decision that needs to be made during
the time of design.
• This layer consists of the Value Objects,
which are java beans that are used as
transport media while the system is required
 to communicate with different layers
• The Value Object holds the data
• This layer is the Model part of MVC
(Model/View/Controller) pattern
In most cases, the presentation layer is the
least thought about and most neglected area
when architecture is being conceptualized.
Common practice is to write some JSP pages
and to fit these with the Controller servlet. More
attention on the design of the presentation layer
will make it simple, reusable and maintainable.
Special attention must be paid to JSP pages,
their navigation and validations. There is a
tendency to write Java code in JSP too. Here,
Struts plays a very crucial role by proving its
own framework. If developers are disciplined in
writing JSP code, they will be able to create
clean JSP pages with Struts tags as well as
custom tags.
Presentation layer has the following
characteristics
• It is developed using JSP (Java Server Page)
• Struts Tag and Taglib Directive should be
used to minimize the scriplet code in JSP
and for enabling i18n
• The functions performed by this layer need
to take care of presentation of the data to
the user based on the user request
• This layer would communicate with
controllers to put forward the user request
to the service
• This layer will also take care of the
presentation (front end) level validation.
Primarily Struts configurable Validator
Component and Java Script (.js) would be
used for validation
• The Presentation layer is the view part of
MVC (Model/View/Controller) pattern
• The Presentation layer takes the help of Java
Beans to display and transport the data to
the Controller
With the help of the Controller, which is part of
the Struts Action Class, the task of delegation is
streamlined.
Some key benefits of the Controller are:
• This layer is developed using Servlets (based
on Struts Action Class), which will delegate
the request from presentation layer to the
service layer depending on the action
performed by servlet class
• This layer takes help of java beans to
transport the data to the immediate next
layer, which is the Business Delegate layer
• Controller servlet classes would be packaged
based on the module
• This layer is the Controller part of MVC
(Model/View/Controller) pattern
Struts Validator Framework has been used
to avoid too much java script code from the
application with using its configurable xml file.
Benefits of Struts Validator Framework
• The Struts Validator framework allows
moving all the validation logic completely in
a centralized place and declaratively
configuring it for an application through
external xml file.
• The other great benefit of the validator is
that it’s extensible. It provides many
standard validation routines out of the box,
but if additional validation rules are
required, the framework is easy to extend
and provides the ability to plug in custom
rules (again without modifying the
application)
Today’s most enterprise applications that
support global businesses and processes,
demand Internationalization (i18n). An
application should have the following
characteristics to support i18n
• Additional languages need to be supported
without requiring code changes
• Text elements, messages and images need
to be stored externally from the source code
• Culturally dependent data such as date and
time, decimal values and currency need to
be formatted correctly for the users’
language and geographic location
• Nonstandard charactersets need to be
supported
• The application should be able to adapt to
new languages and/or regions
The internationalization support provided by the
struts framework focuses almost exclusively on
the presentation of text and images for the
application. The functionality such as accepting
input from nontraditional languages is not
covered within the Struts framework.
Custom Taglib facilitates reuse of some JSP
Components, which helps reduce development
time considerably.
Business Delegate Layer
There is debate whether an application really
requires Business Delegate Dynamic Proxy as it
uses the java reflection API that degrades the
performance and it will be part of the request
path. Basically, a dynamic proxy is an object
created at runtime using reflection, which
implements one or more interfaces. The
advantage is that use of Business Delegate
reduces coupling between presentation-tier
clients and business services.
Session Façade Layer
The FileNet application that was introduced
earlier uses stateless session beans as the
customer plans to expose the application
services as Web Services in the next phase of
development. Besides this, the Session
Facade defines a higher-level business
component that contains and centralizes
complex interactions between lower-level
business components. A Session Facade is
implemented as a session enterprise bean. It
provides a single interface for the functionality
of an application or application subset. It also
decouples lower-level business components
from one another, making designs more flexible
and comprehensible. Fine-grained access
through remote interfaces is inadvisable
because it increases network traffic and latency.
The multiple fine-grained calls create a great
deal of network traffic, and performance suffers
because of the high latency of the remote calls.
Security layer facilitates Authentication and
Authorization services. Authorization is needed
to get access to the specific service assigned to
specific set of users/group. Security component
is designed to secure web server and application
server resources such as JSPs, servlets, beans
etc. This component controls the access to the
web resources and application server resources
by authenticating and authorizing the requests.
The framework does not in itself encompass
implementation of an authentication and
authorization service. The essence of the
framework is to provide a bridge between the
application and enterprise security provider.
Framework uses adapter for delegating the
request to underlying security provider. It takes
the help of LDAP Adapter. The client API does
not change with the adapter. The usage remains
the same always. However, configuration might
change based on the adapter used.
The Business layer takes care of the core
business logic for the application. The Business
layer would contain a set of high-level services,
which would be executed depending on the
client request. The Business layer will
communicate with the Integration layer. This
layer is further subdivided into sub-systems
depending on their functionalities.
Configuration Manager is a generic
framework, which supports XML- based
configuration needs of application components.
Configuration is a java object representation of
the configuration information. The infrastructure
and other components using application shall
use these configurators for reading
configuration information, which is stored in
XML files. It has its own life-cycle methods
which help the component to startup, initialize
and to shutdown the service. The Configuration
Manager is responsible for
• Reading and traversing of XML files.
• Un-marshalling of XML information to the
corresponding Configuration objects.
The solution has a general-purpose cache
component for frequently used static data.
Caching facility should be dynamically
configurable in terms of its size and refresh
time.
At any point of time, cached objects should be
available with multiple simultaneous requests.
The following inputs to the Cache Manager
component need to be configurable:
• The refresh time of the cache
• The size of the cache
JTA (Java Transaction API) was introduced to
handle the transaction.

MQ Integration Approaches
The application has a centralized queue where
any message generated after a database
transaction is stored in the form of an object. A
Message Driven Bean is constantly running to
listen and process the messages and put them
into different queues depending on the
subscriber of the message. Each queue will have
different broker depending on the system need
to be integrated, which will process the
message further.
Custom Adapter
A custom adapter is a custom piece of code
leveraging the FileNet eProcess API and a
corresponding messaging interface such as JMS
to enable the Process Engine to communicate
via message queues.
Types of messages
Outgoing Messages:
• Monitors a process queue (via the Process
Engine API) for incoming work items
• Retrieves each of the work items and
converts the work item to XML
• Posts the XML from the step element to an
associated WebSphere MQ message queue
Incoming Messages:
• Monitors an associated WebSphere MQ
message queue for incoming XML messages
• Retrieves each incoming XML message and
validates it against a given schema for
incoming process requests
• Formulates and executes the process
request (via the Process Engine API) based
on the details within the message
Why framework development is needed recently designed a mission-critical business
process management application for a Fortune
We need to understand why framework 10 insurance customer.
development is really required. Frameworks
provide templates for flexible and modular
architecture. Lets suppose that five Java/J2EE Acknowledgements
solutions are being executed in an organization.
Most of them have to have Infrastrcture, I would like to thank Deviprasad K. and
Security, Database access, MQ Integration, Radhesh Koka for their guidance and valuable
Presentation, and Validation etc. So what is the inputs.
use of developing five times those
components/framework/building block/common
code that are standard across all the five
applications? At least 25% to 30 % of time of
total life cycle goes in designing/building/testing
those general-purpose components.
For e.g. if a project requires 40 resources to
work 8 hours a days, then at least 10 resources
would be engaged in the activities mentioned
above, without focusing on actual core logic. If
design there is a reuse process in place for the
design and development teams, then there
would be significant cost and time saving as the
10 resources mentioned above can be used for
core project design and development activities
and reuse the common components across
projects.. So, if a person’s cost is Rs. 1000 per
day, the company would lose 1000 * 10 =
10,000/day and for 5 projects, the amount
would be Rs 50000/ day. Is this a small
amount?

Conclusion
In today’s every-changing business
environment, where technology is the key to
competitiveness and success, it is absolutely
essential for organizations to have a clearly
thought-out reuse strategy that will effectively
reuse design and development best practices
and components.

References

http://java.sun.com/blueprints/corej2eepatterns/Patterns

Author Profile

Palash Ghosh is a senior technical architect who

has extensive experience in architecting,
designing and developing Java/J2EE based
applications. He is part of the Consulting and
Enterprise Solution business unit and has most