这篇文章主要为大家详细介绍了PHP设计模式之工厂模式，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，在开发大型系统时，往往会出现这样一种情况：

我有一部分基础数据，是类classA是从数据库A读取出来的，其他很多的功能都是基于这个基础数据来操作的。现在呢，我想把数据从数据库A变成从另外的数据源去获取，这时候，要修改起来就比较麻烦，要修改其他很多类的代码。这种设计显然是不够灵活的，换句话说，就是紧耦合的，那么什么是紧耦合呢？紧耦合就是指系统中某个部分的函数或类严重依赖于系统的其他部分中的函数或类的行为和结构。

这时，工厂模式的作用性就体现出来了。

工厂模式

就是解决这样的一些情况的设计方法。

工厂模式是一种类，建立了一个工厂来根据所需来创建对象，这种方式在多态性编程中是很重要的，允许动态替换类，修改配置等。

/*基本工厂模式代码*/

1. <?php
2. /**
3. * 基本工厂模式
4. * */
5. class User {
6. private $username;
7. public function __construct($username) {
8. $this->username = $username;
9. }
10. public function getUser() {
11. return $this->username;
12. }
13. }
14. class userFactory {
15. static public function createUser() {
16. return new User('Jack');
17. }
18. }
19. $user = userFactory::createUser();echo $user->getUser();
20. ?>

工厂模式分为：简单工厂模式、工厂方法模式、抽象工厂模式。

简单工厂模式，通过静态方法创建对象。可以理解成，只负责生产同一等级结构中的任何一个产品，但是不能新增产品。

1. <?php
2. /**
3. *简单工厂模式
4. * */
5. interface userProperties {
6. function getUsername();
7. function getGender();
8. function getJob();
9. }
10. class User implements userProperties{
11. private $username;
12. private $gender;
13. private $job;
14. public function __construct($username, $gender, $job) {
15. $this->username = $username;
16. $this->gender = $gender;
17. $this->job = $job;
18. }
19. public function getUsername() {
20. return $this->username;
21. }
22. public function getGender() {
23. return $this->gender;
24. }
25. public function getJob() {
26. return $this->job;
27. }
28. }
29. class userFactory {
30. static public function createUser($properties = []) {
31. return new User($properties['username'], $properties['gender'], $properties['job']);
32. }
33. }
34. $employers = [
35. ['username' => 'Jack', 'gender' => 'male', 'job' => 'coder'],
36. ['username' => 'Marry', 'gender' => 'female', 'job' => 'designer'],
37. ];
38. $user = userFactory::createUser($employers[0]);
39. echo $user->getUsername();
40. ?>

工厂方法模式，去掉了简单工厂模式中方法的静态属性，使其可以被子类集成，定义一个创建对象的接口，让子类去决定实例化哪个类，可以理解成，用来生产同一等级结构中的固定产品，但是支持增加产品。

1. <?php
2. /**
3. * 工厂方法模式
4. **/
5. interface userProperties {
6. function getUsername();
7. function getGender();
8. function getJob();
9. }
10. interface createUser {
11. function create($properties);
12. }
13. class User implements userProperties{
14. private $username;
15. private $gender;
16. private $job;
17. public function __construct($username, $gender, $job) {
18. $this->username = $username;
19. $this->gender = $gender;
20. $this->job = $job;
21. }
22. public function getUsername() {
23. return $this->username;
24. }
25. public function getGender() {
26. return $this->gender;
27. }
28. public function getJob() {
29. return $this->job;
30. }
31. }
32. class userFactory {
33. private $user;
34. public function __construct($properties = []) {
35. $this->user = new User($properties['username'], $properties['gender'], $properties['job']);
36. }
37. public function getUser() {
38. return $this->user;
39. }
40. }
41. class FactoryMan implements createUser {
42. function create($properties) {
43. return new userFactory($properties);
44. }
45. }
46. class FactoryWoman implements createUser {
47. function create($properties) {
48. return new userFactory($properties);
49. }
50. }
51. class clientUser {
52. static public function getClient($properties) {
53. $fac = new FactoryMan;
54. $man = $fac->create($properties);
55. echo $man->getUser()->getUsername();
56. }
57. }
58. $employers = [
59. ['username' => 'Jack', 'gender' => 'male', 'job' => 'coder'],
60. ['username' => 'Marry', 'gender' => 'female', 'job' => 'designer'],
61. ];
62. $user = clientUser::getClient($employers[0]);
63. ?>

抽象工厂模式，提供一个创建一系列相关或者相互依赖的对象的接口，可以理解成，用来生产不用类型的全部产品，但是不能增加新品，支持增加新的类型。

1. <?php
2. /**
3. * 抽象工厂模式
4. * */
5. interface userProperties {
6. function getUsername();
7. function getGender();
8. function getJob();
9. }
10. interface createUser { //将对象的创建抽象成一个接口
11. function createOpen($properties);//内向创建
12. function createIntro($properties);//外向创建
13. }
14. class User implements userProperties{
15. private $username;
16. private $gender;
17. private $job;
18. public function __construct($username, $gender, $job) {
19. $this->username = $username;
20. $this->gender = $gender;
21. $this->job = $job;
22. }
23. public function getUsername() {
24. return $this->username;
25. }
26. public function getGender() {
27. return $this->gender;
28. }
29. public function getJob() {
30. return $this->job;
31. }
32. }
33. class userFactory {
34. private $user;
35. public function __construct($properties = []) {
36. $this->user = new User($properties['username'], $properties['gender'], $properties['job']);
37. }
38. public function getUser() {
39. return $this->user;
40. }
41. }
42. class FactoryMan implements createUser {
43. function createOpen($properties) {
44. return new userFactory($properties);
45. }
46. function createIntro($properties) {
47. return new userFactory($properties);
48. }
49. }
50. class FactoryWoman implements createUser {
51. function createOpen($properties) {
52. return new userFactory($properties);
53. }
54. function createIntro($properties) {
55. return new userFactory($properties);
56. }
57. }
58. class clientUser {
59. static public function getClient($properties) {
60. $fac = new FactoryMan;
61. $man = $fac->createOpen($properties);
62. echo $man->getUser()->getUsername();
63. }
64. }
65. $employers = [
66. ['username' => 'Jack', 'gender' => 'male', 'job' => 'coder'],
67. ['username' => 'Marry', 'gender' => 'female', 'job' => 'designer'],
68. ];
69. $user = clientUser::getClient($employers[0]);
70. ?>

如有错误，请指正。