A NON PROPRIETARY FRAMEWORK FOR POLICY

CONTROLLED MANAGEMENT OF THE MODEL IN THE MVC

DESIGN PARADIGM

Aaron Jackson

NUI Maynooth, Maynooth, Co. Kildare, Ireland

John G Keating

IBM Dublin Centre for Advanced Studies, Cloughran, Dublin 17, IRELAND

and

NUI Maynooth, Maynooth, Co. Kildare, Ireland

Keywords:

WWW, Content Management, Policy, MVC, XML, JAVA, component-based, Model, View, Controller.

Abstract:

There are a variety of systems available to help automate and control the Web Content Management (WCM)

process. Most of these systems are modelled using the Model-View-Controller (MVC) design paradigm. This

is a design technique frequently adopted by software developers to assist in modularity, ﬂexibility, and re-use

of object oriented web developments. This design paradigm involves separating the objects in a particular

interaction into 3 categories for the purpose of providing a natural set of encapsulating boundaries, encourag-

ing many-to-many relationships along the separate component boundaries, and segregating presentation and

content. These MVC based systems control what is known as static content. In this paper we propose a

new framework for controlling the software tools used in MVC based systems. More precisely, the auto-

matic deployment of model software tools based on XML deﬁned policies. This framework incorporates a

non-proprietary component based architecture and well structured representations of Policies. The Policies

are not embedded in the system, they are generated, and therefore each component is self contained and can

be independently maintained. Our framework will work on a centralized or distributed environment and we

believe that the use of this framework makes it easier to deploy MVC based systems.

1 INTRODUCTION

The pervasive nature of the Web means that it has

become the preferred vehicle for content distribu-

tion. The explosive growth of the Internet, in par-

ticular the World Wide Web, has resulted in heavy

demands being placed on Internet servers and has

raised great concerns in terms of performance, scal-

ability and availability (Yang and Luo, ICDCS 2000).

In order to address these issues, with a main focus

on performance, several approaches have been ex-

amined. The three most prominent approaches to

managing the performance of applications include the

IntServ/RSVP (Braden, 1997) signaling approach, the

DiffServ approach (Blake, 1998) and the content dis-

tribution approach (Akamai, 2004) (Digital, 2004).

Whilst each of these approaches have their own ad-

vantages, they all require a consistent conﬁguration

of a large number of widely distributed devices. The

paradigm of using policy based techniques addresses

this issue and is being developed for Integrated ser-

vices and Differentiated services technologies by var-

ious groups working within the IETF (Moore, 2001).

Policy based management has also been applied to

content distribution networks (Dinesh et al, 2002).

In this paper, we propose a technique for using

policy based technologies to manage code as if it

were content in a content management system. In

particular, we “generate” the software tools used in

the development of a content management system

based on the Model-View-Controller design paradigm

(MVC) (O’Reilly, 2003), speciﬁcally, the model ab-

stract classes. Most management systems today “hard

code” the model. These systems allow for manipula-

tion of the view to create desired web systems. They

tend not to deal with the model and only allow for

the development of the model tools by a prescribed

developer. There are frameworks, like Jakarta struts

(Cavaness, 2003), that allow a developer to extend the

framework for their own needs. This however, still

requires extensive development knowledge and pro-

gramming skill. We propose a framework whereby

451

Jackson A. and G Keating J. (2005).

A NON PROPRIETARY FRAMEWORK FOR POLICY CONTROLLED MANAGEMENT OF THE MODEL IN THE MVC DESIGN PARADIGM.

In Proceedings of the Seventh International Conference on Enterprise Information Systems, pages 451-454

DOI: 10.5220/0002521904510454

 SciTePress

the designer does not need extensive programming

skills as the conﬁguration and design of the deployed

systems can be done simply and effectively by editing

the conﬁguration ﬁles or policies. This framework is

designed for integration with deployment systems for

controller and view components of an MVC design.

This paper is structured into 4 more sections. Sec-

tion 2 outlines the Framework design concepts and

gives an architectural overview. Section 3 describes

the various components and technologies within the

framework. Section 4 illustrates how this framework

is applied to a real world situation and is followed by

the conclusion.

2 FRAMEWORK DESIGN AND

ARCHITECTURAL OVERVIEW

An object-oriented abstract design, also called a

framework, consists of an abstract class for each ma-

jor component (Johnson, 1991). This framework

consists of various independently maintained com-

ponents and uses non-proprietary software technolo-

gies. Application-speciﬁc frameworks cover precise

domains, are highly re-usable and signiﬁcantly reduce

the amount of development required to deploy further

customized applications (Parsons, 1999). With this

in mind, we propose a 3-tiered architectural approach

as illustrated in Figure 1. Our framework is a policy

based system. Given a set of policies, determination

of model software tools to be used may be achieved.

They are a set of rules that the developer issues to

the system for it to know how to deploy. These poli-

cies are in XML format and adhere to a speciﬁc stan-

dardized schema. This framework operates as an ex-

tension to the WCM process framework illustrated in

Figure 2.

Our framework is composed of several intercon-

nected, yet self contained components that are inde-

pendently maintained. The policies for this frame-

work are not embedded in the evaluation software, but

are introduced by the developer. This gives a level of

software manageability that cannot be achieved with

embedded systems. The ﬁrst tier of our framework

deﬁnes the XML polices. This is where the deci-

sions on which tools to use occurs. The policies cre-

ated must adhere to a speciﬁed XML schema for this

framework. XML was chosen as the format for these

policies and other system components in this frame-

work because of its ﬂexibility in structuring content

(W3C, 2004). The second tier in our framework is the

“Controller Model” (CM), which interprets the poli-

cies and formats the selection for the “Software Tool

Repository” (STR) to enable it to select the tools de-

ﬁned by the developer. This information is used by

the third tier, STR.

Figure 1: This ﬁgure illustrates our frameworks

components

Figure 2: This diagram illustrates the integration of our

framework into the WCM process

3 COMPONENTS AND

TECHNOLOGIES

The separate components in this framework utilize

various non-proprietary technologies. Given that each

component is self contained within the framework,

the selection of technologies to use was based around

the premise that the communication protocols would

have to be a generic standard. The ﬁrst tier of the ar-

chitecture used XML formatting for the policies. The

ICEIS 2005 - INFORMATION SYSTEMS ANALYSIS AND SPECIFICATION

452

conﬁgurations are set by the developer at the ﬁrst tier

and enforced into XML based on a schema. When

the policies are formed they are sent to the CM via

the SOAP messaging protocol (W3C, 2004). SOAP

is a messaging protocol that provides a way for ap-

plications to communicate with each other over the

Internet, independent of platform, which serves our

purposes exactly. Additionally, this protocol is light-

weight, requiring a minimal amount of overhead and

occurs over HTTP.

The CM receives the policies, via HTTP and SOAP

from the PM and interprets the information contained

within the policies. This information remotely calls

handlers that deﬁne the ﬁles to be retrieved from the

STR, based on the indexing system within the STR.

It then sends this information to the STR for ﬁle re-

trieval. The CM receives the desired XML ﬁle, un-

marshalls the XML in order to extract the necessary

Java abstract class information. Castor, is used to per-

form this task (W3C, 2004). These unmarshalled Java

programs are the desired abstract Java class informa-

tion for use in the creation of an MVC based web ap-

plication.

The STR is the storage repository and interface for

the abstract Java classes. A native XML database is

used as storage medium (W3C, 2004) (Berkely DB,

2004). Xpath is used to query for information and

it supports DOM and SAX. The lack of alternatives

and the undesirable results obtained with a relational

database resulted in our decision to use this technol-

ogy. Indexing, matching that of our policy informa-

tion, leads to fast retrieval of desired ﬁles from the

database. These XML ﬁles are securely sent back to

the CM for processing.

4 COMPARATIVE

IMPLEMENTATION

An example of how the proposed management of the

model would ﬁt into a real life situation will better

help to illustrate the concept of storing code as con-

tent. A comparison of the “normal” way of writing

this model and a look at how we propose to handle the

model will yield a clearer understanding of our frame-

work. If we look at a simple web development based

on the MVC design paradigm which manages an on-

line employee database for a company. The model

functionality provides us with the ability to store, re-

trieve and edit information in a database about our

employees. The controller was written using Jakarta

Struts with the view written using JSP’s and cascad-

ing stylesheets.

Since we’re dealing with an employee that we want

to insert, we need a way to store information about

this employee that we could hand off to a business ob-

ject (the model layer of MVC). Our model layer will

be responsible for doing the actual insert. So the ﬁrst

thing we need is a class representing our employee.

We’ll make a bean that has just a couple of ﬁelds and

appropriate get and set methods. The object shown

in ’EmployeeDTO’ class will transfer stored informa-

tion from one part of our application to another, and

is therefore called a Data Transfer Object (DTO) or

Value Object. We will create an ’EmployeeService’

class to handle the small amount of business logic we

have.

The main classes used in the Struts framework

are those of org.apache.struts.action.Action. The Ac-

tion classes are the true concrete bridges between the

client’s request and the business layer. Each Action

class will handle one particular type of business op-

eration the client wants to perform. When we sub-

mit our JSP page the Action Servlet and Request-

Processor will ﬁnd this Action class which we asso-

ciated with the /insertEmployee action in the struts-

conﬁg.xml ﬁle and the execute method will be called.

Since the /insertEmployee action uses the Employ-

eeForm the InsertEmployeeAction will have this form

bean of type ActionForm, so we ﬁrst cast this into

type EmployeeForm. Now we want to get the infor-

mation in our EmployeeForm into the EmployeeDTO

so we can pass that off to our Model layer. We created

an instance of EmployeeDTO and then we can use

BeanUtils to transfer the data from EmployeeForm

into the EmployeeDTO. BeanUtils.copyProperties(

employeeDTO, employeeForm ). After copyProper-

ties() the now populated EmployeeDTO is passed off

to the service object and the model layer takes over.

The insertion of data is done by the EmployeeService

class and a collection of Department is returned.

From this illustration we can see that the model is

the logical operator of the system. It performs the ac-

tually desired operations on the data. In this case the

interaction with a database. In comparison to coding

this, our framework would “plug” this model com-

ponent in from a repository of model classes based

on the conﬁgurations needed which are speciﬁed in

an XML policy conﬁguration ﬁle. This would give

a level of abstraction in the model that is not present

using the above methods.

In the above example important information per-

taining to the functionality of the model is essential

information for model selection. Pre-deﬁned classes

are stored in XML format in an XML database. These

ﬁles are indexed so as to relate their functionality. For

example, a ﬁle would have JDBC drivers and knows

that the transport medium to the controller will be

using JavaBeans and is indexed accordingly. These

ﬁles, when selected by the “Controlling Model” in

our Framework, are unmarshalled from XML. Our

framework would plug the model into place. Utiliza-

tion of our framework allows for better re-use of the

A NON PROPRIETARY FRAMEWORK FOR POLICY CONTROLLED MANAGEMENT OF THE MODEL IN THE

MVC DESIGN PARADIGM

453

components and technologies. Using the repository of

pre-deﬁned classes within our framework, allows for

component re-use for similar scenarios and circum-

stances. This is not achievable using existing method-

ologies as the Model would have to be re-written to a

large degree.

Another comparison to make is that of change

within the model and its affects on the system. If a

change in the model has to be made using existing

methods, the model has to be re-created, changed,

tested, re-compiled and implemented back into the

system. Using our framework the classes used in the

model are remotely stored, with respect to the system,

within the XML repository. This allows for remote

changes to be made. Testing and re-compilation will

have to occur in any realtime Object Oriented sys-

tem, however the implementation of the newer model

would be performed by our CM. This comparison,

while simplistic, illustrates how the model can be pre-

deﬁned and then plugged into a development using

our framework.

5 CONCLUSION

This framework is the basis for storing code as con-

tent. We believe that this is the next logical step to-

wards yielding a level of automation and efﬁciency

that cannot occur with the management of static con-

tent alone. Our use of standardized W3C technologies

provides for excellent transferal of knowledge and

skills across heterogeneous platforms and languages,

without the risk of vendor lock-in.

Further development of this concept of storing code

as content is essential for providing a viable exten-

sion to the WCM process. This includes a standard-

ized integration technique for introducing this para-

digm into existing management systems. Ideally, we

believe this design framework should be the new stan-

dard when designing management systems in the fu-

ture. Design of management systems without adopt-

ing this technique would only serve to further stagnate

the evolution of Content Management System design.

This paper also touches on ontological philoso-

phies within computer science. Ontology is the way

we carve up reality to understand and process it, with

information being a product of that carving (Castel,

2002). In this case, the perception of managing code

as content relative to the processes that manage it. Fu-

ture work will address this ontological issue.

REFERENCES

Akamai Technologies Inc. FreeFlow content distribution

service. http://www.akamai.com.

Apache Xindice (2004). Apache Xindice.

http://xml.apache.org/xindice/. 2004 The Apache

Group.

Blake, S. (1998). An Architecture for Differentiated Servers.

Proceeding from IETF RFC 2475, 1998.

Braden, R. (1997). Resource ReSerVation Protocol (RSVP)

Version 1 - Functional Speciﬁcation. Proceedings

from IETF RFC 2205, 1997.

Castor.org(2004). The Castor Project.

http://www.castor.org/. 2004 The ExoLab Group.

Cavaness, C (2003). Programming Jakarta Struts. Book

number 0-596-00328-5.

Digital Island Inc. Footprint content distribution service.

http://www.digitalisalnd.net/services/cd/footprint.shtml.

Dinesh, C., Seraphin C., and Khali A. Policy based Man-

agement of Content Distribution Networks. IBM

Thomas J Watson Research Centre, New York.

TechReport - March 2002.

Felipe Castel. Ontological Computing. Communications of

the ACM. Feb. 2002/Vol 45, No. 2

Johnson, Ralph(1991). Designing Reusable Classes. Jour-

nal of Objectg oriented programming. University of

Illinois.

Moore, B (2001). Policy Core Information Model - Version

1. Proceedings from IETF RFC 3060, 2001.

O’Reilly - MVC arch. (2003). Model-

View-Controller (MVC) Architecture.

http://www.indiawebdevelopers.com/

MVC (2003). Model View Controller.

http://www.exciton.cs.rice.edu/javaresources/DesignPatterns.

Parsons D, Rashid A, Speck A, Telea A(1999). A framework

for object oriented frameworks design. Proceedings

Technology of Object-Oriented Languages and Sys-

tems. IEEE Computer society: Los Alamoitos CA,

1999, 141-151.

Sleepycat Software systems, 2004 Sleepycat Software Sys-

tems Berkeley XML DB http://www.sleepycat.com

W3C.org(2004). Extensible Markup Language - XML. The

W3C worldwide Consortium.

W3C.org(2004). HTTP - communication protocol.

http://www.w3.org/Protocols/. The W3C worldwide

Consortium.

W3C.org(2004). Simple Object Access Protocol (SOAP)

1.1 http://www.w3.org/TR/soap/ The W3C world-

wide Consortium.

Yang, Chu-Sing and Luo, Mon-Yen (2000). A Content

Placement and Management System for Distributed

Web-Server Systems.

ICEIS 2005 - INFORMATION SYSTEMS ANALYSIS AND SPECIFICATION

454