Tài liệu PHP Objects, Patterns, and Practice- P1 pptx

Matt Zandstra, Author of Sams Teach Yourself PHP in You’ll begin with an overview of PHP's object-oriented features, introducing key topics like class declaration, object instantiation,

Matt Zandstra, Author of

Sams Teach Yourself PHP in

You’ll begin with an overview of PHP's object-oriented features, introducing key topics like class declaration, object instantiation, inheritance, and method and property encapsulation You'll also learn about advanced topics including static methods and properties, abstract classes, interfaces, exception handling, object cloning, namespaces, closures and more

The next part of this book is devoted to design patterns, a vocabulary for applying elegant solutions to common problems in software development You’ll learn about pattern concepts and discover how to implement several key pat-terns in your PHP applications You’ll also find chapters on enterprise and data-base patterns

In the last section of this book, you will find practices and tools for managing your codebase and for collaborating with others in development These include Phing, PHPUnit, phpDocumentor, PEAR, and Subversion You’ll also learn how

to use Continuous Integration, a system that brings all these tools together and automates them

I wrote PHP Objects, Patterns, and Practice to provide the kind of overview of

code design and project practice I wish had been available when I first started to develop serious PHP applications I hope this book inspires pleasure in coding and teaches you to build systems that are elegant in both design and management

Matt Zandstra

THE APRESS ROADMAP Pro PHP:

Patterns, Frameworks, Testing, and More

PHP Objects, Patterns, and Practice, Third Edition

Pro PHP Refactoring with Test Driven Design PHP Object-Oriented Solutions

Pro PHP and jQuery

Practical Web 2.0 Applications with PHP

PHP for Absolute Beginners Beginning PHP and MySQL, Third Edition

Companion eBook Available

THIRD EDITION

and Practice

Third Edition

■ ■ ■

Matt Zandstra

means, electronic or mechanical, including photocopying, recording, or by any information storage or retrieval system, without the prior written permission of the copyright owner and the publisher

ISBN-13 (pbk): 978-1-4302-2925-4 ISBN-13 (electronic): 978-1-4302-2926-1 Printed and bound in the United States of America 9 8 7 6 5 4 3 2 1 Trademarked names may appear in this book Rather than use a trademark symbol with every occurrence of a trademarked name, we use the names only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark

President and Publisher: Paul Manning Lead Editor: Michelle Lowman, Matt Wade Technical Reviewer: Wes Hunt

Editorial Board: Clay Andres, Steve Anglin, Mark Beckner, Ewan Buckingham, Gary Cornell, Jonathan Gennick, Jonathan Hassell, Michelle Lowman, Matthew Moodie, Duncan Parkes, Jeffrey Pepper, Frank Pohlmann, Douglas Pundick, Ben Renow-Clarke, Dominic

Shakeshaft, Matt Wade, Tom Welsh Coordinating Editor: Jim Markham Copy Editor: Tracy Brown Collins Compositor: MacPS, LLC

Indexer: Toma Mulligan Artist: April Milne Cover Designer: Anna Ischenko Distributed to the book trade worldwide by Springer-Verlag New York, Inc., 233 Spring Street, 6th Floor, New York, NY 10013 Phone 1-800-SPRINGER, fax 201-348-4505, e-mail orders-ny@springer-sbm.com,

or visit www.springeronline.com

For information on translations, please e-mail info@apress.com, or visit www.apress.com

Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use eBook versions and licenses are also available for most titles For more information, reference our Special Bulk Sales–eBook Licensing web page at www.apress.com/info/bulksales

The information in this book is distributed on an “as is” basis, without warranty Although every precaution has been taken in the preparation of this work, neither the author(s) nor Apress shall have any liability to any person or entity with respect to any loss or damage caused or alleged to be caused directly or indirectly by the information contained in this work

The source code for this book is available to readers at www.apress.com You will need to answer questions pertaining to this book in order to successfully download the code

■Contents at a Glance iii

■Contents v

■About the Author xvii

■About the Technical Reviewer xviii

■Acknowledgments xix

■Introduction to the Third Edition xx

Part 1: Introduction 1

■Chapter 1: PHP: Design and Management 3

Part 2: Objects 9

■Chapter 2: PHP and Objects 11

■Chapter 3: Object Basics 15

■Chapter 4: Advanced Features 41

■Chapter 5: Object Tools 71

■Chapter 6: Objects and Design 99

Part 3: Patterns 121

■Chapter 7: What Are Design Patterns? Why Use Them? 123

■Chapter 8: Some Pattern Principles 131

■Chapter 9: Generating Objects 145

■Chapter 10: Patterns for Flexible Object Programming 169

■Chapter 11: Performing and Representing Tasks 189

■Chapter 12: Enterprise Patterns 221

■Chapter 13: Database Patterns 275

Part 4: Practice 315

■Chapter 14: Good (and Bad) Practice 317

■Chapter 15: An Introduction to PEAR and Pyrus 323

■Chapter 16: Generating Documentation with phpDocumentor 347

■Chapter 17: Version Control with Subversion 361

■Chapter 18: Testing with PHPUnit 379

■Chapter 19: Automated Build with Phing 407

■Chapter 20: Continuous Integration 427

Part 5: Conclusion 451

■Chapter 21: Objects, Patterns, Practice 453

■Appendix A: Bibliography 463

■Appendix B: A Simple Parser 467

■Index 219

■ Contents at a Glance iii

■ Contents v

■ About the Author xvii

■ About the Technical Reviewer xviii

■ Acknowledgments xix

■ Introduction to the Third Edition xx

Part 1: Introduction 1

■ Chapter 1: PHP: Design and Management 3

The Problem 3

PHP and Other Languages 4

About This Book 5

Objects 6

Patterns 6

Practice 6

What’s New in the Third Edition 7

Summary 7

Part 2: Objects 9

■ Chapter 2: PHP and Objects 11

The Accidental Success of PHP Objects 11

In the Beginning: PHP/FI 11

Syntactic Sugar: PHP 3 11

PHP 4 and the Quiet Revolution 12

Change Embraced: PHP 5 13

Into the Future 14

Advocacy and Agnosticism: The Object Debate 14

Summary 14

■ Chapter 3: Object Basics 15

Classes and Objects 15

A First Class 15

A First Object (or Two) 16

Setting Properties in a Class 17

Working with Methods 19

Creating a Constructor Method 21

Arguments and Types 22

Primitive Types 22

Taking the Hint: Object Types 25

Inheritance 27

The Inheritance Problem 27

Working with Inheritance 31

Public, Private, and Protected: Managing Access to Your Classes 35

Summary 39

■ Chapter 4: Advanced Features 41

Static Methods and Properties 41

Constant Properties 44

Abstract Classes 45

Interfaces 47

Late Static Bindings: The static Keyword 48

Handling Errors 51

Exceptions 52

Final Classes and Methods 57

Working with Interceptors 58

Defining Destructor Methods 62

Copying Objects with clone() 63

Defining String Values for Your Objects 65

Callbacks, Anonymous Functions and Closures 66

Summary 70

■ Chapter 5: Object Tools 71

PHP and Packages 71

PHP Packages and Namespaces 71

Autoload 80

The Class and Object Functions 81

Looking for Classes 82

Learning About an Object or Class 83

Learning About Methods 84

Learning About Properties 85

Learning About Inheritance 85

Method Invocation 86

The Reflection API 87

Getting Started 87

Time to Roll Up Your Sleeves 88

Examining a Class 90

Examining Methods 91

Examining Method Arguments 93

Using the Reflection API 94

Summary 97

■ Chapter 6: Objects and Design 99

Defining Code Design 99

Object-Oriented and Procedural Programming 100

Responsibility 103

Cohesion 104

Coupling 104

Orthogonality 104

Choosing Your Classes 105

Polymorphism 106

Encapsulation 107

Forget How to Do It 108

Four Signposts 109

Code Duplication 109

The Class Who Knew Too Much 109

The Jack of All Trades 109

Conditional Statements 110

The UML 110

Class Diagrams 110

Sequence Diagrams 117

Summary 119

Part 3: Patterns 121

■ Chapter 7: What Are Design Patterns? Why Use Them? 123

What Are Design Patterns? 123

A Design Pattern Overview 125

Name 125

The Problem 125

The Solution 126

Consequences 126

The Gang of Four Format 126

Why Use Design Patterns? 127

A Design Pattern Defines a Problem 127

A Design Pattern Defines a Solution 127

Design Patterns Are Language Independent 127

Patterns Define a Vocabulary 127

Patterns Are Tried and Tested 128

Patterns Are Designed for Collaboration 128

Design Patterns Promote Good Design 128

PHP and Design Patterns 129

Summary 129

■ Chapter 8: Some Pattern Principles 131

The Pattern Revelation 131

Composition and Inheritance 132

The Problem 132

Using Composition 135

Decoupling 137

The Problem 137

Loosening Your Coupling 139

Code to an Interface, Not to an Implementation 141

The Concept That Varies 142

Patternitis 143

The Patterns 143

Patterns for Generating Objects 143

Patterns for Organizing Objects and Classes 143

Task-Oriented Patterns 143

Enterprise Patterns 144

Database Patterns 144

Summary 144

■ Chapter 9: Generating Objects 145

Problems and Solutions in Generating Objects 145

The Singleton Pattern 149

The Problem 149

Implementation 150

Consequences 152

Factory Method Pattern 152

The Problem 153

Implementation 155

Consequences 157

Abstract Factory Pattern 157

The Problem 158

Implementation 159

Prototype 162

The Problem 163

Implementation 163

But That’s Cheating! 166

Summary 167

■ Chapter 10: Patterns for Flexible Object Programming 169

Structuring Classes to Allow Flexible Objects 169

The Composite Pattern 169

The Problem 170

Implementation 172

Consequences 175

Composite in Summary 178

The Decorator Pattern 179

The Problem 179

Implementation 181

Consequences 185

The Facade Pattern 185

The Problem 185

Implementation 186

Consequences 187

Summary 187

■ Chapter 11: Performing and Representing Tasks 189

The Interpreter Pattern 189

The Problem 189

Implementation 190

Interpreter Issues 197

The Strategy Pattern 198

The Problem 198

Implementation 199

The Observer Pattern 202

Implementation 204

The Visitor Pattern 210

The Problem 210

Implementation 211

Visitor Issues 215

The Command Pattern 216

The Problem 216

Implementation 216

Summary 220

■ Chapter 12: Enterprise Patterns 221

Architecture Overview 221

The Patterns 222

Applications and Layers 222

Cheating Before We Start 225

Registry 225

Implementation 226

The Presentation Layer 235

Front Controller 235

Application Controller 245

Page Controller 257

Template View and View Helper 262

The Business Logic Layer 264

Transaction Script 265

Domain Model 269

Summary 273

■ Chapter 13: Database Patterns 275

The Data Layer 275

Data Mapper 275

The Problem 276

Implementation 276

Consequences 287

Identity Map 288

The Problem 288

Implementation 289

Consequences 291

Unit of Work 291

The Problem 292

Implementation 292

Consequences 296

Lazy Load 296

The Problem 296

Implementation 297

Consequences 298

Domain Object Factory 298

The Problem 298

Implementation 299

Consequences 300

The Identity Object 301

The Problem 301

Implementation 302

Consequences 307

The Selection Factory and Update Factory Patterns 307

The Problem 307

Implementation 307

Consequences 311

What’s Left of Data Mapper Now? 311

Summary 313

Part 4: Practice 315

■ Chapter 14: Good (and Bad) Practice 317

Beyond Code 317

Borrowing a Wheel 317

Playing Nice 319

Giving Your Code Wings 319

Documentation 320

Testing 321

Continuous Integration 322

Summary 322

■ Chapter 15: An Introduction to PEAR and Pyrus 323

What Is PEAR? 323

Phar Out with Pyrus 324

Installing a Package 326

PEAR Channels 327

Using a PEAR Package 329

Handling PEAR Errors 331

Creating Your Own PEAR Package 334

package.xml 334

Package Elements 334

The contents Element 336

Dependencies 339

Tweaking Installation with phprelease 340

Preparing a Package for Shipment 341

Setting Up Your Own Channel 341

Summary 346

■ Chapter 16: Generating Documentation with phpDocumentor 347

Why Document? 347

Installation 348

Generating Documentation 349

DocBlock Comments 350

Documenting Classes 352

File-Level Documentation 353

Documenting Properties 353

Documenting Methods 355

Creating Links in Documentation 356

Summary 359

■ Chapter 17: Version Control with Subversion 361

Why Use Version Control? 361

Getting Subversion 362

Configuring a Subversion Repository 363

Creating a Repository 363

Beginning a Project 364

Updating and Committing 368

Adding and Removing Files and Directories 371

Adding a File 371

Removing a File 372

Adding a Directory 372

Removing Directories 373

Tagging and Exporting a Release 373

Tagging a Project 373

Exporting a Project 374

Branching a Project 374

Summary 378

■ Chapter 18: Testing with PHPUnit 379

Functional Tests and Unit Tests 379

Testing by Hand 380

Introducing PHPUnit 382

Creating a Test Case 382

Assertion Methods 383

Testing Exceptions 384

Running Test Suites 385

Constraints 386

Mocks and Stubs 388

Tests Succeed When They Fail 391

Writing Web Tests 394

Refactoring a Web Application for Testing 394

Simple Web Testing 397

Introducing Selenium 398

A Note of Caution 403

Summary 405

■ Chapter 19: Automated Build with Phing 407

What Is Phing? 407

Getting and Installing Phing 408

Composing the Build Document 408

Targets 410

Properties 412

Types 416

Tasks 421

Summary 425

■ Chapter 20: Continuous Integration 427

What Is Continuous Integration? 427

Preparing a Project for CI 428

CruiseControl and phpUnderControl 436

Installing CruiseControl 436

Installing phpUnderControl 438

Installing Your Project 440

Summary 450

Part 5: Conclusion 451

■ Chapter 21: Objects, Patterns, Practice 453

Objects 453

Choice 454

Encapsulation and Delegation 454

Decoupling 454

Reusability 455

Aesthetics 455

Patterns 455

What Patterns Buy Us 456

Patterns and Principles of Design 456

Practice 458

Testing 459

Documentation 459

Version Control 459

Automated Build 459

Continuous Integration 460

What I Missed 460

Summary 460

■ Appendix A: Bibliography 463

Books 463

Articles 464

Sites 464

■ Appendix B: A Simple Parser 467

The Scanner 467

The Parser 474

■ Index 487

About the Author

■ Matt Zandstra has worked as a web programmer, consultant, and writer for over a decade He is a

senior developer at Yahoo, and a freelance coder and writer Matt is the author of Teach Yourself PHP in

24 Hours (SAMS) and a contributor to DHTML Unleashed (SAMS) He has written articles for Linux Magazine, Zend.com, IBM DeveloperWorks, and php|architect Magazine, among others He works

primarily with PHP and Java, designing and building web and command-line applications

Matt lives in Liverpool with his wife, Louise, and two children, Holly and Jake

About the Technical Reviewer

■ Wes Hunt is a web-application developer and consultant at 4th Dimension

Development, which builds web solutions for organizations from small to the enterprise level For over a decade, he has used Java and PHP to deliver everything plus the kitchen sink for clients His latest passion is leveraging Flex with a PHP back-end to produce RIAs for clients Wes uses development patterns and best practices in order to spend more time enjoying the outdoors near his home in Montana

Acknowledgments

When you first have an idea for a book (in my case, while drinking good coffee in a Brighton cafe), it is the subject matter alone that grips you In the enthusiasm of the moment, it is easy to forget the scale of the undertaking I soon rediscovered the sheer hard work a book demands, and I learned once again that it’s not something you can do alone At every stage of this book’s development, I have benefited from enormous support

In fact, my thanks must predate the book’s conception The themes of this book first saw the light of day in a talk I gave for a Brighton initiative called Skillswap (www.skillswap.org) run by Andy Budd It was Andy’s invitation to speak that first planted the seeds of the idea in my mind For that, I still owe Andy a pint and much thanks

By chance, attending that meeting was Jessey White-Cinis, another Apress author, who put me in touch with Martin Streicher, who commissioned the book for Apress straightaway

My thanks go out to both Jessey and Martin for seeing potential in the slightest of beginnings

Once again the Apress team has provided enormous support in the face of a very tight deadline, and

my tendency to go quiet as I moved with my family to a new continent in the middle of the project

Thanks to Steven Metsker for his kind permission to re-implement in PHP a brutally simplified version of the parser API he presented in his book Building Parsers in Java

Writing to a deadline is not conducive to family life, and so I must send my thanks and love to my wife, Louise, and to our children, Holly and Jake I have missed you all

Since the publication of the first edition, I have been lucky to receive much enthusiastic and constructive feedback from readers I’m sorry that I haven’t been able to reply to everyone individually, but I’d like to take this opportunity to thank all correspondents for your messages

The soundtrack to the writing of the first edition was provided by John Peel John was a broadcaster who waged a 40-year war on the bland and mass-produced in music simply by championing everything original and eclectic he could lay his hands on John died suddenly in October 2004, leaving listeners around the world bereft He had an extraordinary impact on many lives, and I would like to add my thanks here

Introduction to the Third Edition

When I first had the idea for PHP Objects, Patterns, and Practice, I felt I was swimming against the tide

Many pattern implementations in PHP felt like glorified workarounds due to limitations in the language These days, though, it can be hard to keep up with pace of innovation in PHP objects, design, and project practice

If that's a problem, well, it's the kind you want to have Especially if you have the tools at hand to navigate the risks and opportunities that present themselves

PHP continues to tick items off the object-oriented developer's wish list Since the last edition of this book, we have seen namespaces make it into the language, late static binding, anonymous functions, and closures (if those don't yet mean anything to you, don't worry, they're all covered by this book) PHP is an active language, constantly evolving to meet the needs of its users

For a developer, this presents some interesting challenges Not least, the tension between a stable codebase and the desire to take advantage of the goodies that every new release brings With a good suite of tests, preferably run automatically, tools for collaboration, and an easily installed system, you can improve the design of your code, play with new features, and be fairly sure that you're not breaking stuff

And that's where this book comes in, I hope I want to explore what's exciting, both in the language and in the wider world of object-oriented design At the same time, I want to take in the tools and practices you can use to safeguard your project from the hordes of bugs that lurk beyond sight whenever you make a change

As well as new language features, this edition benefits from coverage of web testing with Selenium, and the ultimate tool of tools: a Continuous Integration server that runs tests, builds your system, and applies diagnostic tools to your project

How real is a web application? It exists as lines of code, of course, bits stored on a computer It exists in its execution on a server But really, for the developer, an application first lives in the imagination It is a structure made up of parts that interlock more or less elegantly Then, if we're lucky, it is realized and deployed, and it really comes alive at the moment someone uses it There, right there, is where the magic of coding lives

That's what this book is really about It's about taking an idea and shaping it, and the pleasure to

be found in the process It's about the shapes of a system in your imagination, and the satisfaction when these shapes are expressed in code And then again when the system actually works It's about the freedom that tests give you to take risks, and the risks that your imagination inspires you to take It's the moment that something you wrote becomes real in the eyes of another

Introduction

■ ■ ■

PHP: Design and Management

When PHP 5 was released early in 2004, among the most important features it introduced was enhanced support for object-oriented programming This stimulated much interest in objects and design within the PHP community In fact, this was an intensification of a process that began when version 4 first made object-oriented programming with PHP a serious reality

In this chapter, I look at some of the needs that coding with objects can address I very briefly summarize the evolution of patterns and related practices in the Java world I look at signs that indicate

a similar process is occurring among PHP coders

I also outline the topics covered by this book

I will look at

• The evolution of disaster: A project goes bad

• Design and PHP: How object-oriented design techniques are taking root in the

You are well on the road to ruin You don’t realize this, of course, because your site looks fantastic It performs well, your clients are happy, and your users are spending money

Trouble strikes when you go back to the code to begin a new phase Now you have a larger team, some more users, a bigger budget Yet without warning, things begin to go wrong It’s as if your project has been poisoned

Your new programmer is struggling to understand code that is second nature to you, though perhaps a little byzantine in its twists and turns She is taking longer than you expected to reach full strength as a team member

A simple change, estimated at a day, takes three days when you discover that you must update 20 or more web pages as a result

One of your coders saves his version of a file over major changes you made to the same code some time earlier The loss is not discovered for three days, by which time you have amended your own local copy It takes a day to sort out the mess, holding up a third developer who was also working on the file Because of the application’s popularity, you need to shift the code to a new server The project has

to be installed by hand, and you discover that file paths, database names, and passwords are hard-coded into many source files You halt work during the move because you don’t want to overwrite the