Php design pattern instance Singleton pattern

This article introduces the Singleton mode method of php design mode instances. if you need to know more, refer to the reference singleton class: 1. the constructor needs to be marked as private, the singleton class cannot be any other

This article introduces the Singleton mode of php design mode instances. For more information, see reference.

Singleton class:

1. the constructor must be marked as private. the singleton class cannot be instantiated in other classes and can only be instantiated by itself.

2. have a static member variable for the instance that saves the class

3. there is a public static method to access this instance. [the getInstance () method is commonly used to instantiate the singleton class, and the instanceof operator can be used to detect whether the class has been instantiated]

Note: You need to create the _ clone () method to prevent objects from being copied.

Purpose:

1. php applications are mainly used for databases. Therefore, a large number of database operations exist in an application. Using the Singleton mode can avoid the resources consumed by a large number of new operations.

2. if you need a class in the system to globally control certain configuration information, you can use the Singleton mode for convenient implementation. refer to the FrontController section of ZF.

3. summary of requests on a page for debugging. because all the code is concentrated in a class, we can set hooks and output logs in the class to avoid var_dump and echo everywhere.

Example of the php Singleton mode.

The instance code is as follows:

2. /**
3. * Singleton mode
4. */
5. Class DanLi {
6. // Static member variable
7. Private static $ _ instance;
8. // Private constructor
9. Private function _ construct (){
10. }
11. // Prevent the object from being cloned
12. Public function _ clone (){
13. Trigger_error ('Clone is not allow! ', E_USER_ERROR );
14. }
15. Public static function getInstance (){
16. If (! (Self: $ _ instance instanceof self )){
17. Self: $ _ instance = new self;
18. }
19. Return self: $ _ instance;
20. }
21. Public function test (){
22. Echo "OK ";
23. }
24. }
26. // Error: $ danli = new DanLi (); $ danli_clone = clone $ danli;
27. // Correct: $ danli = DanLi: getInstance (); $ danli-> test ();
28. ?>

Next we will discuss why we should use the PHP Singleton mode?

Most people understand the purpose of the Singleton model literally. they think that this is a saving of system resources and can avoid repeated instantiation. it is a kind of "family planning ". PHP clears all resources from the memory after each execution of the page. therefore, in PHP, the singleton needs to be re-instantiated every time it is run, thus losing the significance of the Singleton repeated instantiation. in this regard, the PHP Singleton is indeed a bit disappointing. but does the Singleton only have this function and application? The answer is No. let's take a look.

1. php applications mainly involve database applications. Therefore, a large number of database operations exist in an application. when using the object-oriented method for development (nonsense), if you use the Singleton mode, this avoids the resource consumption of a large number of new operations.

2. if you need a class in the system to globally control some configuration information, you can easily implement it using the Singleton mode. for details, refer to the FrontController section of zend Framework.

3. in a page request, debugging is easy, because all the code (such as database operation db) is concentrated in one class, we can set hooks in the class and output logs, this avoids var_dump and echo everywhere.

The instance code is as follows:

2. /**
3. * Singleton mode in design mode
4. * $ _ Instance must be declared as a static private variable
5. * Constructor and Destructor must be declared as private to prevent external programs from new
6. * Class, thus losing the significance of Singleton mode
7. * The getInstance () method must be set to public and must be called
8. * To return a reference to the instance
9. *: The operator can only access static variables and static functions.
10. * New objects consume memory.
11. * Use cases: database connections are the most common scenarios.
12. * After an object is generated in Singleton mode,
13. * This object can be used by many other objects.
14. */
15. Class Example
16. {
17. // Save the instance in this attribute
18. Private static $ _ instance;
19. // The constructor declares private to prevent direct object creation.
20. Private function _ construct ()
21. {
22. Echo 'I am construceted ';
23. }
24. // Singleton method
25. Public static function singleton ()
26. {
27. If (! Isset (self ::$ _ instance ))
28. {
29. $ C =__ CLASS __;
30. Self: $ _ instance = new $ c;
31. }
32. Return self: $ _ instance;
33. }
34. // Prevents users from copying object instances
35. Public function _ clone ()
36. {
37. Trigger_error ('Clone is not allow', E_USER_ERROR );
38. }
39. Function test ()
40. {
41. Echo ("test ");
42. }
43. }
44. // This write method will fail because the constructor is declared as private.
45. $ Test = new Example;
46. // The following is a singleton object of the Example class.
47. $ Test = Example: singleton ();
48. $ Test-> test ();
49. // Copying an object will result in an E_USER_ERROR.
50. $ Test_clone = clone $ test;
51. ?>