2

In a class I have a handling method which performs actions based on what post/get variables are available. Here is a simplified example:

public function handleAll(array $vars) {
    if (isset($vars['var1'])) {
        $this->doThisAction($vars['var1']);
    } else if (isset($vars['var2'])) {
        $this->doAnotherAction($vars['var2']);
    }
}

So at runtime the method could be called like this $handler->handleAll($_POST). The problem is that the variables stored in the $vars array must be named "var1" & "var2" etc. This means that the handling code is coupled with the names of html form elements or get variables in urls (or indeed the keys of any array passed in).

Allowing an array of any variables to be injected makes the method flexible which is necessary as it is also polymorphic. Classes inherit this method and use it to call it's own actions. A result of this is that it is not obvious from the outside what the handling method requires for it to function. This means that the implementation must be examined to find out what it does (unless I copy the code into the phpdoc which would be silly).

I'm not sure how to get around this. Having enormous if/case statements all exposed on index pages (from multiple classes like these) makes for extremely messy code so it is preferable to have all this encapsulated within a method. Also, it makes sense to have it as a method of the class responsible for calling the actions that manipulate it's own state (responsibility driven design). I thought about having each variable as a parameter for the method but for some classes the parameter list would be quite large. Also it would mean that many handleAll() methods of different classes cannot be called automatically as all parameters would need to be explicitly injected for each call, removing the polymorphic aspect.

To sum up I need to keep the method polymorphic but I need some way of decoupling the handling code from user input from html forms or urls. In doing this perhaps there is a way of separating the interface from the implementation too. I'm surprised I can't find any solutions to this already, it seems like it would be a common problem.

Jonathan
  • 1,256
  • 4
  • 12
  • 18
  • Instead of having `handleAll` handle everything, why don't you have individual methods work with the specific post data variables they expect? – Explosion Pills Apr 06 '12 at 19:53
  • If I were to feed in the post variables for each method then I would get huge amounts of if/else code everywhere. Also, polymorphism would be removed which would mean that each method would need to be called explicitly for each class meaning that many calls to handleAll() couldn't be made in a loop for example. If I were to have each method work with specific post variables so dependencies cannot be injected then the coupling issue remains. – Jonathan Apr 06 '12 at 20:08
  • Can't you use one of hte many MVC frameworks? They offer by default what you want. Basically you need the app 'split' in controllers each with its own responsability. And IMO the method you currently have is anything but polymorphic. It's more of a front controller . – MikeSW Apr 06 '12 at 20:55
  • @MikeSW I'm sort of building my own. The method is polymorphic in the sense that it is inherited from a supertype and it acts differently depending on the subtype. There is actually a front controller which invokes other controllers (which can in turn invoke others), idea being that you avoid one massive long ifelse/switch statement if you encapsulate some control code. Anyway that's besides the point. The question isn't about MVC because my question could be applied to any similar issue. – Jonathan Apr 06 '12 at 22:45

2 Answers2

1

I'm not sure if what you describe can even be avoided.

If you have code which requires specific arguments to it - be it in the form of an array containing certain values or whatever else - that function will always depend on the arguments being populated correctly.

If I have function foo($a, $b, $c), I will always have to fill the parameters. If they come from POST, then I would need to take them from POST. The same goes even if the function took an array('a' => ..., 'b' => ..., 'c' => ...) instead.

However, if you wanted to decouple your forms from the parameter list, you could use a simple function to transform the POST array into the format expected by one of your handler functions. I do not really see any reason for this though, since why add the extra complexity if you don't have to?

If you wish to better define what kind of array your handler requires, you could consider having it require an object instead. This approach is sometimes called a parameter object.

The benefits of using a parameter object is that you can easily set up required parameters in the constructor, and use setters for optional ones. Anyone who uses your code can just look at your object's interface to see what values are required.

If the values your handlers use are actually related to each other, I would consider creating an actual business logic type object. Create it using the data from POST, and move the code which processes the values into a method in the object.

Jani Hartikainen
  • 42,745
  • 10
  • 68
  • 86
  • This is a great answer and a great solution. Only thing is that your suggestion is essentially the class's responsibility at present. It's a controller which takes in post/get information which is validated andturned into an object for the model (e.g. CRUD for database table). I encapsulated the validation in the controller so that the it can output feedback about the information it is being sent (e.g. the view outputs a invalid input message specific to the problem). If I move all this validation to the business logic object what do you think is the best way to retain that functionality? – Jonathan Apr 07 '12 at 01:08
  • 1
    Yeah a controller would be the part that is coupled with the POST etc. so that's correct. As for the validation, if you only need it in the controller, you could keep it there. If you decide to move it elsewhere, you could consider making a method which validates the object, and perhaps returns an array containing the errors (if any) or something along those lines. – Jani Hartikainen Apr 07 '12 at 01:23
  • I already have business logic objects so I'll give them another constructor (static method that returns an instance of self) where you inject an array ($_POST/$_GET/whatever) and the other parameters could be array keys to find. e.g. `fromArr($_POST,'title','body')`. Can you define a method in an interface with varying amounts of parameters? In Java I would normally overload. I think I'll redefine handleAll as `route($action, Item $item)`, but subclasses that inherit route cannot define `route($action, SpecificItem $item)`. In Java I would use generics `Controller`. – Jonathan Apr 07 '12 at 11:45
0

Decoupling and automating handling methods, can be painful methods to narrow down too. But there is not so many options, other than, create handlers for eveything. However, I would you like add something. Allow defaults and support variation

function handlePOST() {    }
function handleGET()  {    }
function handleArr()  {    }

Now, these function can hold the variations of the function on their behalf.

Inside however, they is not better way other than to code all the handlers. But switch is shorten them and use separate function for the handling.

switch($_POST['var1']) {
    case "value1": callPostValue1(); break;
    default: callPostDefaultHandler(); break;
}
Starx
  • 77,474
  • 47
  • 185
  • 261