How to design a framework for implementing rules in JSF/Spring Application

Question

We use JSF 1.2 (MyFaces 1.2.2) in the presentation layer, Spring 2.5.3 in the service layer and Hibernate3.2 as persistence layer.
The java application we are building is mostly CRUD but involves tons of business rules which needs to be implemented at both presentation and service layers
We are planning to design a business rule framework so that developers can work on individual business rules without stepping on each other and also to prevent redundant implementation of the same business rules .
Here are the Goals
Solution Goals:
• Business rules are implemented in only one piece of code. i.e. Rule is packaged into a unit
• Business rules have an consistent, identifiable form.
• Rules have to be Abstract
• View technology like JSF says I want to createManufacturer(Manufacturer manuf) passing Manufacturer object as parameter. Then the business rule framework should go and fetch the rules to do the job of createManufacturer () and then return the result.
• Fetch the Rule based on
�X Target object
Is the concrete object on which you are performing the Rule for example Device object
�X Operation Type
Is C R U D Validate
Proposed Solution:
• To have catalog of business rules which will have name of the rulewith parameters and dependencies
• To have Rule Context designed in such a way that it goes and fetches the Rule i.e. give me all the Rules from the RuleContext and the client will decide which Rule to Apply.
We modeled the business rule framework as a variant of Strategy pattern. But this approach has limitation in the sense it requires Rules to be injected into the Service Layer Spring Beans .
Then we looked at other design patterns like Command, Visitor but that doesn’t seems to fit the bill either.
Any pointers/suggestions will be greatly appreciated

Answer 1

"In many cases multiple instances of a single class works just as well."
This sounds a lot like the way I would do something in other languages. I would simply create an array of structs (or records) containing variables like these:
type critter:record
  int x,y; // The critter's position, of course
  int vx,vy; // Used to keep track of velocity
  int ctype; // What kind of thing this is
  int subtype; // Additional flags or info that may affect behavior
  int yadayadayada,etcetera;
end;
var critters:array[0..somelargenumber] of critter;Of course, I suspect that what may work well in Pascal might not work as well in Java. For one thing, I don't think Java even has records per se. It may be necessary to use a class to duplicate that functionality. (Is this true? Or did I miss something?) The array then becomes an array of objects.
Since I'm using classes anyway, I guess it makes sense that I should go all the way, creating interfaces for common functions and subclassing a basic Critter class for each different kind of critter (at least in cases where the behavior and/or rendering methods would be significantly different from the basic class methods).
This is okay as long as I don't go overboard, right?