Business Rules Based Web Services Oriented
Customer Relationship Management System (CRM) Evolution
Yang Xu, Qing Duan and Hongji Yang
Software Technology Research Laboratory, De Montfort University, UK
{yangxu, qduan, hyang}@dmu.ac.uk
Abstract
Customer Relationship Management (CRM) is designed for helping people manage individual customer and build fixed relations with customers by responding rapidly and serving efficiently. The evolution of CRM towards Web Services will improve the flexibility of CRM and make CRM have more efficient on data exchanging [1]. In this paper, we concentrate on the stage of extracting services from specific components based on business rules.
1.
Introduction
The failure implement cases of Customer Relationship Management (CRM) revealed its drawback on disposal business issues such as customer data integration, demand chain partner integration and more seamless access to internal and external systems [2]. The solution is making the CRM system evolve towards Web Services. Web Services could be written to expose the functionalities of any application, or to access the data of an application, even for simple data exchange through Internet [3]. Based on open standards, web services technology allows any piece of software to communicate with each other in a standardised messaging system. For Web Services can be applied as a wrapping technology around existing legacy CRM systems, new solutions can be deployed quickly and recomposed to address the changing business conditions [4]. With minimal programming, Web Services technology enables developers to easily and rapidly wrap the legacy enterprise applications and expose their functionality through a uniform and widely accessible interface over the Internet [5].
Business rules are always changeful during organism’s development. But on a time point, we assume that the extracted business rules are changeless, while the legacy CRM system evolves towards web services. Based on the stable business rules (business logic), we propose the CRM system evolution approach in following sections.
2.
Approach Overview
Web service oriented CRM system evolution would be a complex process. In our approach, it takes the following stages:
Figure 1. Process for CRM System Evolution
1) Translating source code into (Extended Wide Spectrum Language) EWSL by a language specific translator.
2) Abstracting high level specifications via abstractor from EWSL. This has been done based on the previous works [7].
3) Understanding and identifying architectural components. This stage is accomplished based upon CRM business rules (business logic), then sort out components need to be transferred. 4) Specifying services mapping with synthesised components.
5) Retargeting the web-service-oriented CRM system with implementation techniques such as wrapper, adapter and interface would be help.
In next section, Step 3 will be discussed in detail.
3.
Service-Oriented Components Transformation Description
Figure 2. Business Rules Based Evolution
To achieve services mapping from synthesised components, Business Rules Manager (BRM) plays an important role. Business rules are the drivers for specifying and configuring a process. BRM captures and segregate policy decisions from the functional processes. It asserts the necessary data structures, and drives the selection of components and classes [8]. Considering the frequently changed business rules and their difference in different environments, it is efficient to define such rules using rule editor and translator and integrate them into rule management applications. When rules change, the management application allows modification of rules using a simple rule language and integrates the
changes with the application modules [9].
Sometimes hard code parameters can not be used to call a service because they can quickly change based on business rules. Business rules can change from time-to-time to accommodate changes in the business world. Such changes lead to changes in the software application that caters to the business function [10]. A CRM system has various modules such as workflow, client/server, database, transaction management, etc., and if business rules are hard coded in the application, each change becomes expensive and time consuming, leading to severe maintenance problems. The separation of a CRM system model into policy, process, and structural views provides greater flexibility and more understandable representations.
1. After separating out the business logic from the CRM components, Transformer has to replace the function calls (i.e. calls to functions executing the business logic) with the call to BRM. The data is seamlessly shared with the components, and new rules can be added or existing rules can be modified/deleted using the Business Rules Editor.
2. Business Rules Translator or interpreter mode of operation. Translates rules that defined in the rules library into the corresponding language of the application, i.e. EWSL for various abstraction levels. Rules can be expressed in simple IF_THEN_ELSE form.
3. Verifier can be invoked through a simple function/method call from anywhere in the BRM. Once invoked, verifier evaluates the relevant rules and returns the control to the application. Verifier compile rule to ensures no additional runtime overheads and provides guaranteed performance.
4. The approved rules can then be saved in a Business Rules Library. If there have some legacy rules stored in database, BRM can be used to transform them into the format instantly. In addition, deletion and updating of rules can be done in the database [11]. Once this is done, the business rules are embedded into web services based components by BRM. Then Business Rules Based Transformer generate the code that can be compiled and linked with the modules of the application to get the final, integrated application executable file or can be compiled into EJB JAR, COM/DCOM, DLL etc.
4.
An Example: Code Segment - Make CRM Components Work as Web
Services
Assume a customer is new, and this customer has to introduce some personal information. In the case that the store operation would be done by a web service, the configuration for that service could be present in a database. In below Java applet code, the “CustomerStoreService” class is used to store the customer data in the database of CRM system; it is a subclass of “AbstractWebService” - a common base class for Web Services. When the client side requires a “call()” method to the Web Services, it calls the Transformer and requests the loading of response from certain components for such service; this configuration data, often cached in Business Rules Library, is used by the Transformer to create the parameter and values lists and passes them to the CRM components. While Transformer obtain the configuration required data from relative components, it passes those data to the service, calling the generic “setParameter()” method:
public class CustomerStoreService extends AbstractWebService { public void call() {
BusinessRulesManager manager =
new BusinessRulesManager( "CustomerStoreService" ); //add parameters and values
manager.prepare( this, session ); //calls the channel super.call(); }
}
public class BusinessRulesManager { String serviceName;
Map cache;
public BusinessRulesManager( String serviceName ) { this.serviceName = serviceName;
initDAO(); }
public void prepare( WebServices service, ApplicationSession session ) { //loads the service configuration
ConfigurationData conf = loadConfiguration();
//obtain the values of the parameters, based on data session Map values = loadValues( session );
//values the service parameters prepareService( service, conf, values ); }
//load cache-enabled configuration data ConfigurationData loadConfiguration() { ...
}
//obtains data from the relative components Map loadValues( ApplicationSession session ) { ...
}
//sets the parameter calling the setParameter() method on the service prepareService( WebServices, ConfigurationData conf, Map values ) { ...
}
5.
Summary
In this paper, we describe a business rules based web services oriented CRM system evolution framework. In the framework, legacy CRM components are transferred to Web Services over the BRM. The BRM shows that the basic CRM components can be represented as Web Services by business rules editing and verifying. Our next step is working towards to create full-fledged CRM components evolution processes and utilise UML diagrams to describe.
6.
Reference and Bibliography
[1] M. Davids, “How to Avoid the 10 Biggest Mistakes in CRM”, J. Business Strategy, Nov./Dec. 1999, pp. 22–26.
Supply Chain,” CRC Press-St. Lucie Press, 1999.
[3] T. M. Chester, "Cross-Platform Integration with XML and SOAP ", In IT Professiona l, volume 3, issue 5, 2001, pp. 26-34.
[4] C. K. Nam and J. J. Bae, “A Framework for Processing Active Documents,” 6th International Symposium on science and technology, 2002, pp.122-125.
[5] M. Bigatti, “Web Services Integration Patterns,” in MySQL Users Conference, 2005,
[6] G. Alonso and F. Casati “Web Services and Service-Oriented Architectures,” in Proceedings of the 21st International Conference on Data Engineering, 2005.
[7] H. Yang and M. Ward, Successful Evolution of Software Systems. London: Artech House, 2003. [8] J. J Jeng, D. Flaxer and S. Kapoor, “RuleBAM: A Rule-Based Framework for Business Activity
Management,” in Proceedings of the 2004 IEEE International Conference on Services Computing (SCC’04), 2004.
[9] L. Lin, S. Embury and B. Warboys “Business rule evolution and measures of business rule evolution,” in Proceedings of the Sixth International Workshop on Principles of Software Evolution (IWPSE’03), 2003.
[10] A. Perkins, “Business Rules = Meta-Data,” 34th Technology of Object-Oriented Languages and Systems Conference, 2000, pp. 285-294.
[11] A. Kovaeif and A. Groznik, “The Business Rule-Transformation Approach,” 26th International Conference information Technology Interfaces ITI, 2004, pp.114-117.
[12] T. Puschmann and R. Alt, “Enterprise Application Integration - The Case of the Robert Bosch Group,” in Proceedings of the 34th Hawaii International Conference on System Sciences, 2001. [13] L. O'Brien and D. Smith, “Working Session: Program Comprehension Strategies for Web Service
and Service-oriented Architectures,” in Proceedings of the 12th IEEE International Workshop on Program Comprehension, 2004.
[14] A. Groznik and A. Kovacic, “Business Renovation: From Business Process Modelling to Information System Modelling,” 24thInternational Conference Information Technology Interfaces IT1, 2002, pp.405-409.
[15] I. Ho, Z. Komiya, B. Pham, H. Kobayashi and K. Yana, “An Efficient Framework for Business Software Development,” in Proceedings of the 2003 International Conference on Cyberworlds (CW’03), 2003.
[16] M. Wermelinger, G. Koutsoukos and J. L. Fiadeiro, “Using Coordination Contracts for Flexible Adaptation to Changing Business Rules,” in Proceedings of the Sixth International Workshop on Principles of Software Evolution (IWPSE’03), 2002.
[17] D. Sun, K. Wong and D. Moise, “Lessons Learned inWeb Site Architectures for Public Utilities,” in Proceedings of the Fifth IEEE International Workshop on Web Site Evolution (WSE’03), 2003. [18] J. J. Jeng, H. Chang and J. Y. Chung, “A Policy Framework for Business Activity Management,”
