The pattern is NOT CoR. Does anyone look at the code? How do you code
without knowing what is going on at the foundations of this design?
<snip>
On 2/20/06, Paul Benedict <[EMAIL PROTECTED]> wrote:
>
> You want
> to be able to plug into the request processor, which is a CoR pattern,
</snip>
I guess this is like the Bush approach. Repeat a lie enough times and the hoi
polloi will buy it hook line and sinker. If I am wrong, I am wrong, but I
am looking at the code and it is NOT a CoR pattern. It is merely a bunch of
procedural based code out of commons chain iterating away.
I assume that you mean the ComposableRequestProcessor and not the
RequestProcessor in 1.3. Neither are CoR. But, if you think that the
RequestProcessor in 1.3 is CoR there is not much hope. The
ComposableRequestProcessor, once again, merely implements chain in commons
and I should that code before. Here it is all once again:
ComposableRequestProcessor:
public void process(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
// Create and populate a Context for this request
ServletWebContext context = new ServletWebContext();
context.initialize(getServletContext(), request, response);
context.getAttributes().put("catalog", this.catalog);
context.getAttributes().put(Constants.MODULE_CONFIG_KEY,
this.moduleConfig);
// Create and execute the command.
Command command = this.catalog.getCommand("servlet-standard");
try {
command.execute(context);
} catch (Exception e) {
// Execute the exception processing chain??
throw new ServletException(e);
}
// Release the context.
context.release();
}
ChainBase:
public boolean execute(Context context) throws Exception {
// Verify our parameters
if (context == null) {
throw new IllegalArgumentException();
}
// Freeze the configuration of the command list
frozen = true;
// Execute the commands in this list until one returns true
// or throws an exception
boolean saveResult = false;
Exception saveException = null;
int i = 0;
int n = commands.length;;
for (i = 0; i < n; i++) {
try {
saveResult = commands[i].execute(context);
if (saveResult) {
break;
}
} catch (Exception e) {
saveException = e;
break;
}
}
// Call postprocess methods on Filters in reverse order
if (i >= n) { // Fell off the end of the chain
i--;
}
boolean handled = false;
boolean result = false;
for (int j = i; j >= 0; j--) {
if (commands[j] instanceof Filter) {
try {
result =
((Filter) commands[j]).postprocess(context,
saveException);
if (result) {
handled = true;
}
} catch (Exception e) {
; // Silently ignore
}
}
}
// Return the exception or result state from the last execute()
if ((saveException != null) && !handled) {
throw saveException;
} else {
return (saveResult);
}
}
RequestProcessor
public void process(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
// Wrap multipart requests with a special wrapper
request = processMultipart(request);
// Identify the path component we will use to select a mapping
String path = processPath(request, response);
if (path == null) {
return;
}
if (getDebug() >= 1) {
log("Processing a '" + request.getMethod() +
"' for path '" + path + "'");
}
// Select a Locale for the current user if requested
processLocale(request, response);
// Set the content type and no-caching headers if requested
processContent(request, response);
processNoCache(request, response);
// General purpose preprocessing hook
if (!processPreprocess(request, response)) {
return;
}
// Identify the mapping for this request
ActionMapping mapping = processMapping(request, response, path);
if (mapping == null) {
return;
}
// Check for any role required to perform this action
if (!processRoles(request, response, mapping)) {
return;
}
// Process any ActionForm bean related to this request
ActionForm form = processActionForm(request, response, mapping);
processPopulate(request, response, form, mapping);
if (!processValidate(request, response, form, mapping)) {
return;
}
// Process a forward or include specified by this mapping
if (!processForward(request, response, mapping)) {
return;
}
if (!processInclude(request, response, mapping)) {
return;
}
// Create or acquire the Action instance to process this request
Action action = processActionCreate(request, response, mapping);
if (action == null) {
return;
}
// Call the Action instance itself
ActionForward forward =
processActionPerform(request, response,
action, form, mapping);
// Process the returned ActionForward instance
processActionForward(request, response, forward);
}
--
"You can lead a horse to water but you cannot make it float on its back."
~Dakota Jack~
