Java Spring MVC无状态到有状态切换

Question

Although I have tagged this as a java/spring question it can be easily asked of any mvc framework with stateless controllers. I know rails uses simple stateless controllers for instance so perhaps you guys know how to best solve this problem. I can best describe the problem with java/spring mvc which is the implementation - forgive the java jargon.

The issue

We are having trouble coming up with a satisfactory way of performing stateless-to-stateful handover in spring mvc. In essence given a structure like:

Model: Unit With the states: withdrawn, available, unavailable And the operations: getOutline() and getHelp()

Controller: UnitController with operations: displayOutline() and displayHelp()

We need a way to check the state of the unit before we execute the operation displayOutline() (because the unit itself may be withdrawn and so the user should be forwarded to a withdrawn page).

We have tried to do this a number of ways including:

The dead simple way (any language)

All methods in the controller that require an 'available' state unit call a method isAvailable() in the first line of its implementation. Obviously there lots of replication here, it reeks.

The AOP way (Java specific)

An @Around advice can be created called UnitAccess which does the check and reroutes the control flow (ie instead of calling proceed() which would invoke the underlying method it calls another method on the controller). This seems like a hack and not really what AOP if for, it does remove the replication but adds complexity and reduces transparency.

An Interceptor (Provided by servlet architecture but probably doable in other frameworks)

Which checks the unit state and essentially changes the actual URL call. Again this does not seem right. We don't like the idea of invoking model logic before getting to a controller.

We have thought about

Command Pattern

Creating a command pattern structure which (with the use of inheritance) can return a withdrawn view or valid displayOutline view. As the execute method will perform the checks in a super() call and the specific logic inside the concrete commands. Ie creating a object structure like

DisplayOutlineCommand extends UnitCommand

    public void execute(){
        super();
        // must be ok, perform getOutline()
    }

And finally, using a custom Exception

Calling getAvailableUnit() on a service level object which will do the checks for availability, etc before returning the unit. If the unit is withdrawn then it will throw a UnitWithdrawnException which could be caught by the servlet and handled by returning an appropriate view. Were still not convinced. We are also not hot on the idea of using an exception for normal flow control.

Are we missing something? Is there an easy way to do this under spring/another stateless controller framework?

Answer 1

Maybe I'm missing the point, but why should a user come to the controller if the Unit is withdrawn?

I would argue it is best to ensure that normally pages don't link to a controller that require the Unit to be 'OK', if that Unit is not 'OK'. If the state of the Unit changes between the time the referring page is rendered and the actual call comes in to the controller (it is not longer 'OK'), then the use of an exception to handle that event seems perfectly fine to me (like having an exception when an optimistic locking error occurs).

Answer 2

Perhaps you haven't described the whole problem, but why not put the check in displayOutline() itself? perhaps route to a displayOutlineOrHelp() method, which looks essentially like

ModelAndView displayOutlineOrHelp(...)  {
    Unit unit = ... //code to get the unit the request refers to

    return unit.isAvailable() ? displayOutline(...) : displayHelp(...);   
}