Weitere Kapitel dieses Buchs durch Wischen aufrufen
Target audience Application architect, software architect, developer In this chapter you will learn The major design issues for early business rule management system An overview of the major architectural choices for a business rules application An overview of the major design issues surrounding the integration of rule engines integration options An overview of the major design issues and best practices regarding reengineering legacy applications to introduce business rules Key points Business rule management is about more than authoring – and managing – executable rules: we need to manage the early deliverables (rule capture and analysis) and ensure proper traceability through the various stages of ABRD. Business rule applications can come in many shapes and sizes: rules are architecture-neutral. Most BRMSs offer many rule engine deployment options.The integration of rule-based decisioning into applications depends, in part, on the architecture of the application, and in part, on rule-specific architectural requirements. There are some proven patterns to reengineer the decisioning aspect of a legacy application using rule engines.
Bitte loggen Sie sich ein, um Zugang zu diesem Inhalt zu erhalten
Sie möchten Zugang zu diesem Inhalt erhalten? Dann informieren Sie sich jetzt über unsere Produkte:
BRS RuleTrack is a product of Business Rule Solutions, http://www.BRSolutions.com.
RuleXpress is a product of RuleArts, check http://www.RuleArts.com.
CASE for Computer Assisted Software Engineering. Our use of the terms early BRMS and late BRMS is actually borrowed from CASE terminology, where early CASE refers to functionalities focusing on requirements and modeling, and late CASE focuses on design and coding. That distinction concerning CASE is blurring with model-driven development as we now have powerful CASE tools that can perform round-trip engineering from platform independent UML models all the way to platform-specific Java (or C#) code, and back.
The Fannie Mae underwriting manual calls it a guideline, but according to the classification of rules discussed in Chap. 4, this rule represents a constraint, i.e., a must-have condition.
We may massage the text using some of the linguistic templates described in Chap. 4.
We dealt with one customer who prohibited the use of J2EE technology.
Some authors will talk about architectural metaphors. These basically mean the same thing, except that architectural styles have a precise meaning in the academic literature.
By the way, so is your web browser – as an application. Whether it is Internet Explorer, or Firefox, or Opera, or Safari, the executable is on your machine, and it executes on your machine.
If the local workspace happens to reside on a remote disk, the operating system will make that transparent to the IDE.
For example, the salespeople may synchronize their local inventory database (on their PC) with the corporate inventory database when they are back to their hotel at night.
Java Webstart, e.g., is about as simple as it gets.
This diagram is borrowed from the J2EE literature. See for example http://java.sun.com/javaee.
Contrast this with typical OO RPC calls: the caller and receiver processes need to be active for the “call to be delivered”. In fact, part of CORBA’s lifecycle management services consists of instantiating a server process whenever a client makes a call to a dead server object.
This is often problematic because in the case of a RPC call, it is not always possible to tell when a connection exception occurred during the request or the response. Unless we use a transactional context, retrying a failed call may not be appropriate.
The J2EE platform does offer other APIs to integrate with legacy EIS, e.g., JCA.
JRules offers half a dozen variants of the rule execution service option, to be discussed in Chap. 13.
Meaning the application code archive (in Java, it could be a Java Archive, or jar, a Web Archive, or war, or an Enterprise Archive, or ear).
From, a deployment point of view, the business rules approach does enable us to treat business logic as data that is separate from program code. However, with the first deployment approach that data is often bundled with the program code in the same application code archive.
As a consequence, the JSR94 API is too “verbose” in those cases where we are manipulating a rule engine directly, and too “coarse” for those instances where we are using the API to invoke a rule execution service. For example, JRules’s rule engine API is more “efficient” than JSR94, and its rule execution server (RES) API offers finer control than JSR94.
We have come across an insurer that was carrying a policy that was over a hundred years old. Even though the initial policyholder deceased quite a while ago, the policy was converted in some form of trust in the name of the beneficiaries.
The requirement that a claim refer to an actual policy is an example of a referential integrity constraint. In database terms, such a constraint can be specified by stating that a database table column is a foreign key to another table.
To us, it is clear that syntactic data validation rules are out of scope of the BRMS.
They could still be managed by the same early BRMS as the other rules, but not in formal//executable form.
It is pretty much a settled debate in the Java community that EJBs are an overkill for many situations, and even more so for entity beans. Because there are alternatives to EJBs, even in those situations where the full EJB services are needed (persistence, transactions, security), corporate architects may be tempted by a no-exception policy. The alternative, a case by case analysis of every project, would be too energy consuming!
If we replace a thin client by a rich client, and introducing business rules to handle client-side validation, say, then we are changing the application flow.
RPC: remote procedure call, the way synchronous distributed applications work.
The Java Connector Architecture (JCA) makes this distinction, in theory, irrelevant.
GoF: Gang of Four, i.e., Gamma, Helm, Johnson, and Vlissides, authors of the landmark book on Design Patterns: Elements of Reusable Design, published by Addison-Wesley, in 1994.
The Body Mass Index of an adult is defined as the weight (in kilograms), divided by the square of height, in meters. A BMI of 18.5–25 is considered normal.
Relational DBMSs (e.g., Oracle) may support joins across databases//servers, and make those reasonably efficient through built-in optimizations. Attempting to perform the join “programmatically” by first accessing the joined data sources through the JCA API, for example, would be far more problematic from both a development and run-time performance perspective.
Thomas Erl, Service-Oriented Architecture: Concepts, Technology & Design Prentice Hall/PearsonPTR (2005). ISBN 0-131-85858-0
Hafedh Mili, Ali Mili, Sherif Yacoub, and Edward Addy, Reuse-Based Software Engineering: Techniques, organizations, and controls, John Wiley & Sons, 2002, ISBN 0-471-39819-5
Tony Morgan, Business Rules and Information Systems: Aligning IT with Business Goals, Addison-Wesley, 2002, ISBN 0-201-74391-4
Michael P. Papazoglou, Paolo Traverso, Schahram Dustdar, Frank Leymann, “Service-Oriented Computing: State of the Art and Research Challenges”, IEEE Computer, nov. 2007, pp. 38-45
Michael Huhns & Munindar P. Singh, “Service-Oriented Computing: Key Concepts and Principles,” IEEE Internet Computing, Jan/Feb 2005, pp. 75-81
Olaf Zimmermann, Pal Krogdahl & Clive Gee, “Elements of Service-Oriented Analysis and Design”, http://www.ibm.com/developerworks/webservices/library/ws-soad1/
Kyo C. Kang, Sholom G. Cohen, James A. Hess, William E. Novak, A.Spencer Peterson, Feature-Oriented Domain Analysis (FODA) – Feasibility Study, CMU/SEI-90-TR-21, Software Engineering Institute, Nov, 1990
Barbara von Halle, Business Rules Applied, John Wiley & Sons, 2001, ISBN 0-471-41293-7
- Issues in Designing Business Rule Applications
Mr. Jérôme Boyer
Prof. Hafedh Mili
- Springer Berlin Heidelberg
- Chapter 7
Neuer Inhalt/© ITandMEDIA