Flyweight mode in design mode Flyweight mode

Flyweight mode definition: Avoid a large number of small costs of small classes (such as spending memory), allowing you to share a class (category).

Why use? The principle of object-oriented language is that everything is an object, but if you really use, sometimes the number of objects may be very large, such as word processing software, if each text is used as an object, thousands of words, objects The number is thousands, undoubtedly spent memory, then we still have to "seek to deposit", find the common point of these object groups, design a category, package can be shared, and some features depends on the application (Context ), Is unsuitable, this is also two important concepts in Flyweight Internal state Intrinsic and external status Extrinsic points.

To put the white point, it is first pinching a raw model, and then the specific model of each character is produced, it is clear that different new objects are required here, so Factory mode often appears in the Flyweight mode .flyweight The internal status is used to share, Flyweight Factory is responsible for maintaining a Flyweight Pool to store objects in the internal state.

Flyweight mode is an improved program efficiency and performance mode, which will greatly speed up the running speed of the program. Applications a lot: such as reading a series of strings from a database, there are many repetitions in these strings, then we These strings can be stored in the Flyweight pool (Pool).

how to use?

Let's start with the Flyweight abstraction interface:

Public interface flyweight {public void Operation (EXTRINSICSTATE STATE);} // Appreciation data type (self-design) public interface extrinsicState {}

Below is a concreteflyweight, increasing memory space for internal status, and ConcreteflyWeight must be shared. Any state it saves must be internal (Intrinsic), that is, ConcreteFlyWeight must be in combination with it. Not related.

Public Class ConcreteflyWeight Implements Flyweight {Private IntrinsicsTate State; Public Void Operation (ExtrinsicsTate State) {// Specific Operation}}

Of course, not all Flyweight specific implementation subclasses need to be shared, so there is another non-shared Concreteflyweight:

Public Class UnsharedConcreteflyweight Implements Flyweight {Public Void Operation (ExtrinsicState State) {}}

FlyWeight Factory is responsible for maintaining a FlyWeight pool (stores internal state), when the client requests a shared flyweight, this factory first searches if there is already available in the pool. If there is, Factory just simply returns this object, otherwise, create a New objects, add to the pool, return to send this object. Pool

public class FlyweightFactory {// Flyweight pool private Hashtable flyweights = new Hashtable (); public Flyweight getFlyweight (Object key) {Flyweight flyweight = (Flyweight) flyweights.get (key); if (flyweight == null) {// create new Concreteflyweight flyweight = new contReteflyWeight (); flyweights.put (key, flyweight);}}}

Thus, the basic framework of the Flyweight pattern already in place, we look at how call: FlyweightFactory factory = new FlyweightFactory (); Flyweight fly1 = factory.getFlyweight ( "Fred"); Flyweight fly2 = factory.getFlyweight ( "Wilma"); .. ....

From the call, it seems to be a pure Factory, but the mystery is in the internal design of Factory.

FlyWeight mode Apply in the data source such as XML, we have mentioned above, when reading a string from the data source, there is definitely, then we can use the Flyweight mode to improve efficiency, with a record CD as an example, in an XML In the file, multiple CDs are stored.

Each CD has three fields: 1. Caver dates (YEAR) 2. Singer name and other information (Artist) 3. Record track (title)

Among them, the name of the singer may be repeated, that is, there may be a number of different tracks of different tracks of the same singer. We will "sing" as a shared concreteflyweight. Other two fields as UnsharedConcreteflyweight.

First look at the contents of the data source XML file: