Where to implement a factory method?

Question

I've been trying to grasp OOP concepts and while I do get the general ideas behind most of them, I often find myself in need of some advice regarding their practical implementation. One of such cases is the factory method.

I'm writing a PHP app that's going to handle requests incoming from both web and command-line interface, so I came up with the following simple class inheritance structure to cover both types of requests:

abstract class Request {
}

class HttpRequest extends Request {
}

class CliRequest extends Request {
}

Now I need a factory method that would return a concrete Request instance, depending on the value returned by php_sapi_name():

public function create() {
    if(php_sapi_name() === 'cli')
        return new CliRequest();
    else
        return new HttpRequest();
}

My question is: where do I put it? I can think of at least three possibilities:

1) Static method in a separate class:

class RequestFactory {
    public static function create() {
        // ...
    }
}

2) Regular method in a separate class (would require instantiating the class first):

class RequestFactory {
    public function create() {
        // ...
    }
}

3) Static method in the abstract parent class:

abstract class Request {
    public static function create() {
        // ...
    }
}

What are the pros and cons of each solution and which would be considered "proper" and why?

Answer 1

All these possibilities will work as expected. I don't really get any "cons" as it fulfils, what is IMHO, your encapsulation objective. Now, let's look at Factory Method pattern essence:

Define an interface for creating an object, but let the classes that implement the interface decide which class to instantiate. The Factory method lets a class defer instantiation to subclasses.

I'm not sure if what you're willing to do perfectly matches this definition.

Instead, it looks like you want to implement something called "Simple Factory" in which instantiation process is encapsulated into a class.

But having this kind of method directly into the abstract class that defines the interface of your "Request" objects doesn't look like a bad idea.

As Nicolas said, it's a rather common pattern in Java, C#, and Cocoa lands.

For these reasons, my choice would go to 3rd option

Answer 2

So, I have an idea, to do what I think you want, using method overloading.

class Request {

    private $request;
    private $valid = true;
    private $type;
    private $vars;
    private $methods;

    public function __construct() {
        $this->type = php_sapi_name() === 'cli' ? 'cli' : 'http';
        if($this->is_cli()) $this->request = new CliRequest();
        else if($this->is_http())  $this->request = new HttpRequest();
        else {
            $this->valid = false;
            return;
        }
        $this->vars = get_class_vars($this->request);
        $this->methods = get_class_methods($this->request);
    }

    public function __get( $var ){
        if(!$this->valid) return false;
        if(!in_array($var, $this->vars)) return false;
        return $this->request->$var;
    }

    public function __set( $var , $val ){
        if(!$this->valid) return false;
        if(!in_array($var, $this->vars)) return false;
        return $this->request->$var = $val;
    }

    public function __call( $meth, $args ){
        if(!$this->valid) return false;
        if(!in_array($meth, $this->methods)) return false;
        return call_user_func_array($this->request->$var, $args);
    }

    public function is_cli( ){
        return $this->type == 'cli';
    }

    public function is_http( ){
        return $this->type == 'http';
    }


}

// Then, when calling the function...
$request = new Request;
$request->variable; // will get the variable from the Cli or Http request class
$request->method("a","b","c"); // Will run the method from the Cli or Http request class