PHP design pattern FlyWeight (flyweight pattern)

Use flyweight technology to effectively support a large number of fine-grained objects. Friends in need can refer to it.

Flyweight PatternIt is called "Flyweight Pattern" in English. I am very grateful to the person who translated Flyweight Pattern into Flyweight Pattern, because this word makes the way of using this pattern clear. It is expressed; if it is translated into featherweight mode or flyweight mode, etc., although it can implicitly show the purpose of using this mode, it still misses 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.

Advantages of flyweight mode:

1) The advantage of flyweight mode is that it can greatly reduce the number of objects in memory, so that the same object or similar objects only exist in memory. Save a copy.

2) The external state of the flyweight mode is relatively independent and will not affect its internal state, so that the flyweight object can be shared in different environments.

Disadvantages of flyweight mode:

1) Flyweight mode makes the system more complex and requires separation of internal and external states, which complicates the logic of the program.

2) In order to make the object shareable, the flyweight mode needs to externalize the state of the flyweight object, and reading the external state makes the running time longer.

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.

Let’s take a look at the following program to get a general understanding of the flyweight mode.

<?php 
/** 
* 享元模式 
* 
* 运用享元技术有效的支持大量细粒度的对象 
*/ 
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."<br/>"; 
$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(&#39;artist1&#39;)); 
$objCD2 = new CD(); 
$objCD2->setTitle("title2"); 
$objCD2->setArtist($objArtistFactory->getArtist(&#39;artist2&#39;)); 
$objCD3 = new CD(); 
$objCD3->setTitle("title3"); 
$objCD3->setArtist($objArtistFactory->getArtist(&#39;artist1&#39;));

The essence of flyweight model is three points:

1. Fine-grained objects that are used extensively by the system, how fine the granularity should be, and how large the amount should be , just look at the flyweight mode used in jdk. In jdk, Integer, Character, String, etc. all use the flyweight mode. They are all the most basic data types , it cannot be said that it is not detailed, they frequently participate in calculations, it cannot be said that it is not small.

2. Divide the intrinsic attributes/state and 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. There is a netizen Well said, it is the state of no difference, that is, there is no difference between objects of the same type after extrinsic attributes are taken away. The intrinsic state of the object is the soul of the object. As long as the soul and soul are indistinguishable, then the objects will also be indistinguishable. At the same time, Only these undifferentiated spirits can be shared. I think this is 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 flyweight; because the flyweight object cannot be created at will by the client, otherwise it will be meaningless. Factories usually provide a caching mechanism to save already created flyweights.

Object-orientedAlthough it 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 object-oriented cost problem. 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 model 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 s1. The specific object referenced, which realizes the sharing of the same string in memory. If a new string object is created every time the s1="abc" operation is executed, the memory overhead will be very large.

The above is the detailed content of PHP design pattern FlyWeight (flyweight pattern). For more information, please follow other related articles on the PHP Chinese website!