PHP Responsibility Pattern Singleton Pattern_PHP Tutorial

Patterns are very important for object-oriented development. A pattern helps us create objects that perform specific tasks, becoming the responsibility of a class. The pattern also allows us to modify a class without modifying the code related to the class. This is called polymorphism of the class.

The singleton pattern is also called the responsibility pattern, which is used to create a single functional access point in the application. Let's discuss and firmly grasp the idea and application of singletons.

In complex systems, using the singleton pattern is especially useful in maintaining synchronization of application state. All singleton classes have at least the following three elements:

• A constructor marked private.
• Static member variables that hold instances of the class.
• Access public static methods of this instance.

Program List: Singleton mode class

<?php
class Fruit
{
    // Hold an instance of the class
    private static $instance;
    
    // A private constructor; prevents direct creation of object
    // 防止类被当作实例使用，就是无法使用此类创建对象
    private function __construct() 
    {
        echo 'I am constructed';
    }
    // The singleton method
    public static function singleton() 
    {
        if (!isset(self::$instance)) {
            $c = __CLASS__;
            self::$instance = new $c;
        }
        return self::$instance;
    }
    
    // Example method
    public function showColor()
    {
        echo 'My color is !';
    }
    // Prevent users to clone the instance
    public function __clone()
    {
        trigger_error('Clone is not allowed.', E_USER_ERROR);
    }
}
// This would fail because the constructor is private
//$test = new Fruit();
// This will always retrieve a single instance of the class
$test = Fruit::singleton();
echo '<br />';
$test->showColor();
// This will issue an E_USER_ERROR.
//$test_clone = clone $test;
?>

Program execution result:

I am constructed
My color is !

There is something special about this app. Unlike ordinary classes, singleton classes cannot be instantiated directly, they can only be instantiated by themselves. To achieve this effect, the __construct() method must be marked private. If you try to construct an object using the private constructor, you will get an access level error.

So how do singleton classes work? A singleton class is to provide an instance to other classes and use it to call various methods. The singleton class returns a reference through the internally stored instance, so the singleton class does not repeatedly occupy memory and system resources, allowing other parts of the application to better use resources. Therefore, it is best to use the singleton mode to build your database access, so that too many database connection instances will not be created, allowing your system to run faster.

An empty __clone() method is necessary to prevent the object from being copied or cloned.

self::$instance can detect whether the class has been initialized. If the static member holding the instance is empty or is not yet an instance of the class itself, then the instance will be created and saved in the variable holding the instance.

Program List: Singleton without private constructor

A loose singleton with no private constructor and no reference to itself. I don’t know if it’s still considered a pattern.

  
<?php
class Fruit {
  	public static $height = 2;
  	public static $weight = 2;
  	public static function getInstance() {
    	return new Fruit();
  	}
  	public function getHeight() {
    	return self::$height;
  	}
  	public function getWeight() {
    	return self::$weight;
  	}
  	public function setHeight($value) {
    	if($value > 0 && $value < 100) self::$height = $value;
  	}
  	public function setWeight($value) {
    	if($value > 0 && $value < 100) self::$weight = $value;
  	}
  	public function __toString() {
    	return 'Fruit[height=' . self::$height . ', weight=' . self::$weight . ']';
  	}
}
// try to set data before any objects is created
Fruit::$height = 55;
$msm1 = Fruit::getInstance();  // use the getInstance() method
$msm2 = new Fruit();           // use the default constructor
$msm2->setWeight(78);                           // set data with an instantiated object
echo $msm1 . '<br />';
echo $msm2 . '<br />';
echo Fruit::getInstance() . '<br>';
echo (new Fruit());
?>

Program execution result:

Fruit[height=55, weight=78]
Fruit[height=55, weight=78]
Fruit[height=55, weight=78]
Fruit[height=55, weight=78]

Program List: Database connection responsibilities

<?php
	class Database {
		private $_db;
		static $_instance;
		
		private function __construct() {
			$this->_db = pg_connect('dbname=example_db');
		}
		
		private __clone() {};
		
		public static function getInstance() {
			if( ! (self::$_instance instanceof self) )
			{
				self::$_instance = new self();
			}
			return self::$_instance;
		}
		
		public function query($sql)
		{
			return pg_query($this->_db,$sql);
		}
	}
?>

How to use this singleton class?

$db = Database::getInstance();
$db->query('SELECT * FROM example_table');

That is to say, the method of obtaining the object is slightly different, and its use is not special with other objects.

http://www.bkjia.com/PHPjc/752400.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/752400.htmlTechArticlePattern is very important for object-oriented development. A pattern helps us create objects that perform specific tasks, becoming the responsibility of a class. Patterns also allow us to modify a class,...