Example of design mode factory mode and Singleton mode in php

1 Factory mode the factory mode is a type. it has some methods for creating objects for you. you can use the factory class to create objects instead of using new directly, if you want to change the created object

1. factory model

Factory mode is a type. it has some methods for creating objects for you. you can use the factory class to create objects instead of using new directly, if you want to change the type of the created object, you only need to change the factory, and all the code using the factory will be changed automatically.

The main function is to reduce coupling. the code is as follows:

1. Abstract class Operation {
2. Abstract public function getValue ($ num1, $ num2 );
3. Public function getAttr (){
4. Return 1;
5. }
6. }
7. Class Add extends Operation {
8. Public function getValue ($ num1, $ num2 ){
9. Return $ num1 + $ num2;
10. }
11. }
12. Class Sub extends Operation {
13. Public function getValue ($ num1, $ num2 ){
14. Return $ num1-$ num2;
15. }
16. }
17. Class Factory {
18. Public static function CreateObj ($ operation ){
20. Switch ($ operation ){
21. Case '+': return new Add ();
22. Case '-': return new Sub ();
23. }
25. }
26. }
27. $ Op = Factory: CreateObj ('-');
28. Echo $ Op-> getValue (3, 6 );

Generally used in real development as a database selection class.

Example 2 shows an example using the factory method. the code is as follows:

2. Interface IUser
3. {
4. Function getName ();
5. }
6. Class User implements IUser
7. {
8. Public static function Load ($ id)
9. {
10. Return new User ($ id );
11. }
12. Public static function Create ()
13. {
14. Return new User (null );
15. }
16. Public function _ construct ($ id ){}
17. Public function getName ()
18. {
19. Return "Jack ";
20. }
21. }
22. $ Uo = User: Load (1 );
23. Echo ($ uo-> getName (). "n ");
24. ?>

This code is much simpler. it only has one IUser interface and one User class that implements this interface. the User class has two static methods for creating objects. PHP improves efficiency through the factory mode.

The following code creates the following four files:

1. // Index. php
3. Include_once ("f. inc. php ");
4. $ F = new factory;
5. $ T1 = & $ f-> create ('T1 ');
6. Echo $ t1-> getName ();
7. Echo $ config;
8. ?>
9. // F. inc. php
11. Class factory
12. {
13. Function factory ()
14. {
15. $ This-> mClasses = array ('T1' => 't1. inc. php', 'T2' => 'T2. inc. php ');
16. }
17. Function & create ($ class)
18. {
19. If (! Class_exists ($ class ))
20. {
21. Require_once ($ this-> mClasses [$ class]);
22. }
23. Return new $ class;
24. }
25. }
26. ?>
27. // T1.inc. php
29. Global $ config;
30. $ Config = 'surfchen ';
31. Class T1
32. {
33. Var $ mName = 'name: T1 ';
34. Function getName ()
35. {
36. Return $ this-> mName;
37. }
38. }
39. ?>
40. // T2.inc. php
42. Class T2
43. {
44. Function T2 ()
45. {
46. Echo 'T2 is OK ';
47. }
48. }
49. ?>

In index. php, we use a factory class to create other class instances.

In the factory, an array $ this-> mClasses is saved in the format of array ("Class name" => "class file path ").

When we create a class instance through factory: create (), in create (), we first check whether the class exists. if it does not exist, the class file corresponding to the class is included according to $ this-> mClasses. Create and return an instance of this class.

In this way, we only need to include the factory class file into the execution script (such as index. php). you may have noticed that t1.inc. the code in php is as follows: global $ config; $ config = 'surfchen ';

2. Singleton mode

Simply put, the PHP Singleton mode is a function implemented by a class, and only one instance of this class exists in the entire application;

The factory model emphasizes object-oriented Polymorphism. it can encapsulate functional differences to implement common functions externally, such as database links, we may need to write different methods to implement database links, but as an application, it does not need to know whether the database uses MySQL or Oracle, and it only needs to use query () this method can be used to execute the corresponding operations on the database, thus shielding the differences and making the class more robust! The code is as follows:

1. Class Mysql {
2. Public static $ conn;
3. Public static function getInstance (){
4. If (! Self: $ conn ){
5. New self ();
6. Return self: $ conn;
7. } Else {
8. Return self: $ conn;
9. }
11. }
12. Private function _ construct (){
13. Self: $ conn = "mysql_connect:"; // mysql_connect ('','','')
14. }
16. Public function _ clone ()
17. {
18. Trigger_error ("Only one connection ");
19. }
20. }
21. Echo Mysql: getInstance ();
22. Echo Mysql: getInstance ();

In practice, it is used together as a database connection class and a factory mode. calling the Singleton mode based on parameters can improve resource usage efficiency.