PHP design pattern FlyWeight (flyweight pattern)_PHP tutorial

Flyweight Pattern is called "Flyweight Pattern" in English. I am very grateful to the person who translated Flyweight Pattern into Flyweight Pattern, because this word clearly expresses the way this pattern is used; if it is translated into Featherweight Pattern or Flyweight mode, etc., although they can implicitly express the purpose of using this mode, they still miss the key to this mode.

The Flyweight pattern is defined as: using a share to avoid the overhead of having a large number of objects with the same content. The most common and intuitive of this overhead is the loss of memory. Flyweight mode efficiently supports a large number of fine-grained objects in a shared manner.

The core concept of sharing is reflected in the name and definition, so how to achieve sharing? We must know that every thing is different, but there are certain commonalities. If only the same things can be shared, then the flyweight model can be said to be unfeasible; therefore, we should try our best to share the commonalities of things while retaining Its personality. In order to achieve this, the flyweight model distinguishes between intrinsic state and extrinsic state. The inner state is the commonality, and the outer state is the individuality.

Note: Shared objects must be immutable, otherwise all changes will occur (except if there is such a requirement).

The intrinsic state is stored inside the flyweight and will not change with changes in the environment and can be shared; the extrinsic state cannot be shared and changes with changes in the environment, so The extrinsic state is maintained by the client (because changes in the environment are caused by the client). In each specific environment, the client passes the extrinsic state to the flyweight to create different objects.

First, take a look at the program below to get a general understanding of the flyweight mode.

Copy code The code is as follows:

/**
* Flyweight mode
*
* Use flyweight technology to effectively support a large number of fine-grained objects
*/
class CD
{
private $_title = null;
private $_artist = null;
public function setTitle($title)
{
$this->_title = $title;
}
public function getTitle()
{
return $this->_title;
}
public function setArtist($artist)
{
$this->_artist = $artist;
}
public function getArtist($artist)
{
return $this->_artist;
}
}
class Artist
{
private $_name;
public function __construct($name)
{
echo "construct ".$name."
";
$this->_name = $name;
}
public function getName()
{
return $this->_name;
}
}
class ArtistFactory
{
private $_artists = array();
public function getArtist($name)
{
if(isset($this->_artists[$name]))
{
return $this->_artists[$name];
} else {
$objArtist = new Artist($name);
$this->_artists[$name ] = $objArtist;
return $objArtist;
}
}
}
$objArtistFactory = new ArtistFactory();
$objCD1 = new CD();
$ objCD1->setTitle("title1");
$objCD1->setArtist($objArtistFactory->getArtist('artist1'));
$objCD2 = new CD();
$objCD2 ->setTitle("title2");
$objCD2->setArtist($objArtistFactory->getArtist('artist2'));
$objCD3 = new CD();
$objCD3- >setTitle("title3");
$objCD3->setArtist($objArtistFactory->getArtist('artist1'));

The essence of flyweight model is three points:

1. For fine-grained objects that are widely used by the system, how fine the granularity and how large the amount should be, just look at the flyweight mode used in jdk. In jdk, Integer, Character, String, etc. all use flyweight Schemas, they are the most basic data types, they are very detailed, they frequently participate in calculations, they are very large.
2. Divide the intrinsic attributes/state and the extrinsic attributes/state of the object; the so-called intrinsic state is the state that exists inside the object and does not change with the environment. One netizen said it very well, that is, there is no difference. State, that is, after removing the extrinsic attributes, there is no difference between objects of the same type. The intrinsic state of the object is the object's spirit. As long as the spirit and spirit are indistinguishable, then the objects will also be indistinguishable. At the same time, only these undifferentiated spirits can Being shared, I think this is also the reason why Flyweight is translated into flyweight. The extrinsic state is a state specified by the client and changes with the environment; for Integer, its intrinsic attribute is actually its value (of course it has no extrinsic attribute);
3. Use a factory to control the creation of flyweights; because flyweight objects cannot be created at will by the client, otherwise it will be meaningless. Factories usually provide a caching mechanism to save already created flyweights.

Although object-oriented solves the problem of abstraction very well, for an actual running software system, we also need to consider the cost of object-oriented. The flyweight pattern solves the cost of object-oriented. Flyweight mode uses object sharing to reduce the number of objects in the system, thereby reducing the memory pressure that fine-grained objects bring to the system.

The flyweight mode is not commonly used in general project development, but is often used in the development of the underlying system to solve system performance problems. The String type in Java and .Net uses the flyweight pattern. If a string object s1 has been created in Java or .NET, then the next time the same string s2 is created, the system will just point the reference of s2 to the specific object referenced by s1, which achieves the same string Sharing in memory. If a new string object is created every time the s1="abc" operation is executed, the memory overhead will be very large.

http://www.bkjia.com/PHPjc/323622.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/323622.htmlTechArticleThe flyweight pattern is called "Flyweight Pattern" in English. I am very grateful to the person who translated Flyweight Pattern into flyweight pattern. A strong person, because this word clearly expresses the way this pattern is used...