PHP에서 팩토리 디자인 패턴이란 무엇입니까?

PHP에서 팩토리 디자인 패턴이란 무엇입니까?

---

이것은 가장 간단한 용어로 무엇을 하는가? 당신이 당신의 어머니 또는 누군가에게 거의 기쁘게 설명하는 척하십시오.

---

팩토리는 객체를 생성합니다. 그래서 당신이 만들고 싶다면

 class A{
    public $classb;
    public $classc;
    public function __construct($classb, $classc)
    {
         $this->classb = $classb;
         $this->classc = $classc;
    }
  }

객체를 만들 때마다 다음 코드를 수행해야하는 것에 의존하고 싶지 않을 것입니다.

$obj = new ClassA(new ClassB, new Class C);

그것이 공장이 들어오는 곳입니다. 우리는 그것을 처리 할 공장을 정의합니다.

class Factory{
    public function build()
    {
        $classc = $this->buildC();
        $classb = $this->buildB();
        return $this->buildA($classb, $classc);

    }

    public function buildA($classb, $classc)
    {
        return new ClassA($classb, $classc);
    }

    public function buildB()
    {
        return new ClassB;
    }

    public function buildC()
    {
        return new ClassC;
    }
}

이제 우리가해야 할 일은

$factory = new Factory;
$obj     = $factory->build();

진짜 장점은 클래스를 바꾸고 싶을 때입니다. 다른 ClassC를 전달하고 싶다고 가정 해 보겠습니다.

class Factory_New extends Factory{
    public function buildC(){
        return new ClassD;
    }
}

또는 새로운 ClassB :

class Factory_New2 extends Factory{
    public function buildB(){
        return new ClassE;
    }
}

이제 상속을 사용하여 클래스 생성 방법을 쉽게 수정하여 다른 클래스 세트에 넣을 수 있습니다.

좋은 예는 다음과 같은 사용자 클래스 일 수 있습니다.

class User{
    public $data;
    public function __construct($data)
    {
        $this->data = $data;
    }
}

이 클래스 $data는 데이터를 저장하는 데 사용하는 클래스입니다. 이제이 클래스에 대해 세션을 사용하여 데이터를 저장한다고 가정 해 보겠습니다. 공장은 다음과 같습니다.

class Factory{
    public function build()
    {
        $data = $this->buildData();
        return $this->buildUser($data);
    }

    public function buildData()
    {
        return SessionObject();
    }

    public function buildUser($data)
    {
        return User($data);
    }
}

이제 모든 데이터를 데이터베이스에 저장하고 싶다고 가정 해 보겠습니다. 변경하는 것은 정말 간단합니다.

class Factory_New extends Factory{
    public function buildData()
    {
        return DatabaseObject();
    }
}

팩토리는 개체를 조립하는 방법을 제어하는 ​​데 사용하는 디자인 패턴이며 올바른 팩토리 패턴을 사용하면 필요한 사용자 지정 개체를 만들 수 있습니다.

---

실제 공장처럼 무언가를 만들어 돌려줍니다.

이런 걸 상상 해봐

$joe = new Joe();
$joe->say('hello');

또는 공장 방법

Joe::Factory()->say('hello');

팩토리 메서드의 구현은 새 인스턴스를 만들고 반환합니다.

---

여러 리소스를 처리하고 높은 수준의 추상화를 구현하려는 경우 팩토리 디자인 패턴이 매우 좋습니다.

이것을 다른 섹션으로 나누자.

Suppose you have to implement abstraction and the user of your class doesn't need to care about what you've implemented in class definition.

He/She just need to worry about the use of your class methods.

e.g. You have two databases for your project

class MySQLConn {

        public function __construct() {
                echo "MySQL Database Connection" . PHP_EOL;
        }

        public function select() {
                echo "Your mysql select query execute here" . PHP_EOL;
        }

}

class OracleConn {

        public function __construct() {
                echo "Oracle Database Connection" . PHP_EOL;
        }

        public function select() {
                echo "Your oracle select query execute here" . PHP_EOL;
        }

}

Your Factory class would take care of the creation of object for database connection.

class DBFactory {

        public static function getConn($dbtype) {

                switch($dbtype) {
                        case "MySQL":
                                $dbobj = new MySQLConn();
                                break;
                        case "Oracle":
                                $dbobj = new OracleConn();
                                break;
                        default:
                                $dbobj = new MySQLConn();
                                break;
                }

                return $dbobj;
        }

}

User just need to pass the name of the database type

$dbconn1 = DBFactory::getConn("MySQL");
$dbconn1->select();

Output:

MySQL Database Connection
Your mysql select query execute here

In future you may have different database then you don't need to change the entire code only need to pass the new database type and other code will run without making any changes.

$dbconn2 = DBFactory::getConn("Oracle");
$dbconn2->select();

Output:

Oracle Database Connection
Your oracle select query execute here

Hope this will help.

---

In general a "factory" produces something: in the case of Object-Orientated-Programming, a "factory design pattern" produces objects.

It doesn't matter if it's in PHP, C# or any other Object-Orientated language.

---

Factory Design Pattern (Factory Pattern) is for loose coupling. Like the meaning of factory, data to a factory (produce data) to final user. By this way, the factory break the tight coupling between source of data and process of data.

---

A factory just generates an object or objects.

You may have a factory that builds a MySQL connection.

http://en.wikipedia.org/wiki/Factory_method_pattern

---

This answer is in relation to other post in which Daniel White said to use factory for creating MySQL connection using factory pattern.

For MySQL connection I would rather use singleton pattern as you want to use same connection for accessing the database not create another one.

---

The classic approach to instantiate an object is:

$Object=new ClassName();

PHP has the ability to dynamically create an object from variable name using the following syntax:

$Object=new $classname;

where variable $classname contains the name of class one wants to instantiate.

So classic object factoring would look like:

function getInstance($classname)
{
  if($classname==='Customer')
  {
    $Object=new Customer();
  }
  elseif($classname==='Product')
  {
    $Object=new Product();
  }
  return $Object;
}

and if you call getInstance('Product') function this factory will create and return Product object. Otherwise if you call getInstance('Customer') function this factory will create and return Customer type object (created from Customer() class).

There's no need for that any more, one can send 'Product' or 'Customer' (exact names of existing classes) as a value of variable for dynamic instantiation:

$classname='Product';
$Object1=new $classname; //this will instantiate new Product()

$classname='Customer';
$Object2=new $classname; //this will instantiate new Customer()

---

For the record, in easy words, a factory like @Pindatjuh said, returns a object.

So, what's the difference with a constructor? (that does the same)

1. a constructor uses his own instance.
2. Something i want to so something more advanced and i don't want to bloat the object (or add dependencies).

3. Constructor is called when each instance is created. Sometimes you don't want that.

   For example, let's say that every time i creates an object of the class Account, i read from the database a file and use it as a template.

Using constructor:

class Account {
      var $user;
      var $pwd;
      var ...
      public __construct() {
         // here i read from the file
         // and many other stuff
      }
}

Using factory:

class Account {
      var $user;
      var $pwd;
      var ...
}
class AccountFactory {
      public static Create() {
         $obj=new Account();
         // here we read the file and more stuff.
         return $obj;
      }

참고URL : https://stackoverflow.com/questions/2083424/what-is-a-factory-design-pattern-in-php