Do you understand PHP design patterns_PHP tutorial

Design patterns have brought me a lot of benefits. There are more than 20 design patterns in JAVA, and there are five common design patterns in PHP. Let’s take a detailed look at the PHP design patterns. Factory mode. The book PHP Design Patterns introduced design patterns to the software community. The authors of the book are Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides Design (commonly known as the "Gang of Four"). The core concepts behind the design patterns presented are very simple.

After years of software development practice, Gamma et al. discovered certain patterns with fixed designs, just like architects design houses and buildings, which can Develop templates for where a bathroom should be or how a kitchen should be constructed. Using these templates, or design patterns, means designing better buildings faster. The same concept applies to software. Design patterns not only represent a useful way to develop robust software faster, but they also provide a way to encapsulate large ideas in friendly terms. For example, you might say that you are writing a messaging system that provides loose coupling, or you might say that you are writing a pattern named Observer.

Demonstrating the value of patterns with smaller examples is very difficult. This often feels like overkill, since patterns actually work in large code bases. This article does not demonstrate a large application, so you need to think about ways to apply the principles of the example in your own large application—not the code itself demonstrated in this article. This is not to say that you shouldn't use patterns in small applications. Many good applications start out as small applications and progress to large applications, so there's no reason not to build on these types of solid coding practices.

Now that you know about PHP design patterns and how useful they are, let’s take a look at the five commonly used patterns in PHP V5.

Factory Pattern

Originally in the book Design Patterns, many design patterns encourage the use of loose coupling. To understand this concept, it's best to talk about the arduous journey that many developers go through working on large systems. When you change one piece of code, problems can occur, and cascading breaks can occur in other parts of the system—parts you once thought were completely unrelated.

The problem is tight coupling. Functions and classes in one part of the system are heavily dependent on the behavior and structure of functions and classes in other parts of the system. You want a set of patterns that allow these classes to communicate with each other, but you don't want to tie them tightly together to avoid interlocking.

In large systems, a lot of code depends on a few key classes. Difficulties may arise when these classes need to be changed. For example, suppose you have a User class that reads from a file. You want to change it to a different class that reads from the database, however, all your code references the original class that reads from the file. At this time, it will be very convenient to use factory mode.

Factory pattern is a class that has certain methods that create objects for you. You can use a factory class to create objects without using new directly. This way, if you want to change the type of object created, you only need to change the factory. All code using this factory is automatically changed.

The manifest displays an instance of the factory class. The server side of the equation consists of two parts: a database and a set of PHP pages that allow you to add feedback, request a list of feedback, and get articles related to a specific feedback.

List.Factory1.php

<ol class="dp-xml">
<li class="alt"><span><span class="tag"></span><span class="tag-name">php</span><span> </span></span></li>
<li class=""><span>interface IUser  </span></li>
<li class="alt"><span>{  </span></li>
<li class=""><span>function getName();  </span></li>
<li class="alt"><span>}  </span></li>
<li class=""><span> </span></li>
<li class="alt"><span>class User implements IUser  </span></li>
<li class=""><span>{  </span></li>
<li class="alt"><span>public function __construct( $id ) { }  </span></li>
<li class=""><span> </span></li>
<li class="alt"><span>public function getName()  </span></li>
<li class=""><span>{  </span></li>
<li class="alt"><span>return "Jack";  </span></li>
<li class=""><span>}  </span></li>
<li class="alt"><span>}  </span></li>
<li class=""><span> </span></li>
<li class="alt"><span>class UserFactory  </span></li>
<li class=""><span>{  </span></li>
<li class="alt"><span>public static function Create( $id )  </span></li>
<li class=""><span>{  </span></li>
<li class="alt"><span>return new User( $id );  </span></li>
<li class=""><span>}  </span></li>
<li class="alt"><span>}  </span></li>
<li class=""><span> </span></li>
<li class="alt">
<span>$</span><span class="attribute">uo</span><span> = </span><span class="attribute-value">UserFactory</span><span>::Create( 1 );  </span>
</li>
<li class="">
<span>echo( $uo-</span><span class="tag">></span><span>getName()."n" );  </span>
</li>
<li class="alt">
<span></span><span class="tag">?></span><span> </span>
</li>
</ol>

http://www.bkjia.com/PHPjc/446468.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/446468.htmlTechArticleDesign patterns have brought me a lot of benefits. There are more than 20 design patterns in JAVA, and in PHP There are also five common design patterns. Let’s take a detailed look at the factory in PHP design patterns...