book

Modernizing Legacy Applications in PHP

Name: Modernizing Legacy Applications in PHP
Author: Paul Jones
ISBN: 9781787124707

by Paul Jones

August 2016

Intermediate to advanced

286 pages

5h 31m

English

Packt Publishing

Read now

Unlock full access

Modernizing Legacy Applications in PHP
Table of Contents
Modernizing Legacy Applications in PHP
Credits
Foreword
About the Author
Acknowledgement
www.PacktPub.com
eBooks, discount offers, and moreWhy subscribe?
Preface
1. Legacy Applications
The typical PHP applicationFile StructurePage ScriptsRewrite or Refactor?The Pros and Cons of RewritingWhy Don't Rewrites Work?The Context-switching problemThe Knowledge problemThe Schedule ProblemIterative Refactoring

Legacy Frameworks
Framework-based Legacy ApplicationsRefactoring to a Framework
Review and next steps
2. Prerequisites
Revision controlPHP versionEditor/IDEStyle Guide
Test suite
Review and next steps
3. Implement an Autoloader
PSR-0
A Single Location for Classes
Add Autoloader CodeAs a Global FunctionAs a ClosureAs a Static or Instance method
Using The __autoload() Function
Autoloader Priority
Common Questions
What If I Already Have An Autoloader?What are the Performance Implications Of Autoloading?How Do Class Names Map To File Names?
Review and next steps
4. Consolidate Classes and Functions
Consolidate Class FilesFind a candidate includeMove the class fileRemove the related include callsSpot check the codebaseCommit, Push, Notify QADo ... While
Consolidate functions into class files
Find a candidate includeConvert the function file to a class fileChange function calls to static method callsSpot check the static method callsMove the class fileDo ... While
Common Questions
Should we remove the autoloader include call?How should we pick files for candidate include calls?What if an include defines more than one class?What if the one-class-per-file rule is disagreeable?What if a Class or Function is defined inline?What if a definition file also executes logic?What if two classes have the same name?What about third-party libraries?What about system-wide libraries?For functions, can we use instance methods instead of static methods?Can we automate this process?
Review and next steps
5. Replace global With Dependency Injection
Global DependenciesThe replacement processFind a global variableConvert global variables to propertiesSpot check the classConvert global properties to constructor parametersConvert instantiations to use parametersSpot check, Commit, Push, Notify QADo ... While
Common Questions
What if we find a global in a static method?Is there an alternative conversion process?What about class names in variables?What about superglobals?What about $GLOBALS?
Review and next steps
6. Replace new with Dependency Injection
Embedded instantiation
The replacement process
Find a new keywordExtract One-Time creation to dependency injectionExtract repeated creation to factory
Change instantiation calls
Spot Check, Commit, Push, Notify QADo ... WhileCommon QuestionsWhat About Exceptions and SPL Classes?What about Intermediary Dependencies?Isn't this a lot of code?Should a factory create collections?Can we automate all these Injections?
Review and next steps
7. Write Tests
Fighting test resistance
The way of Testivus
Setting up a test suiteInstall PHPUnitCreate a tests/ directoryPick a class to testWrite a test caseDo ... WhileCommon QuestionsCan we skip this step and do it later?Come On, Really, Can We Do This Later?What about hard-to-test classes?What about our earlier characterization tests?Should we test private and protected methods?Can we change a test after we write it?Do we need to test Third-party libraries?What about code coverage?
Review and next steps
8. Extract SQL statements to Gateways
Embedded SQL StatementsThe extraction processSearch for SQL statementsMove SQL to a Gateway classNamespace and Class namesMethod namesAn initial Gateway class methodDefeating SQL InjectionWrite a testReplace the original codeTest, Commit, Push, Notify QADo ... WhileCommon QuestionsWhat about INSERT, UPDATE, and DELETE Statements?What about Repetitive SQL strings?What about complex query strings?What about queries inside non-Gateway classes?Can we extend from a base Gateway class?What about multiple queries and complex result structures?What if there is no Database Class?
Review and next steps
9. Extract Domain Logic to Transactions
Embedded Domain LogicDomain logic patterns
The Extraction Process
Search for uses of GatewayDiscover and Extract Relevant Domain LogicExample ExtractionSpot check the remaining original codeWrite tests for the extracted transactionsSpot check again, Commit, Push, Notify QADo ... WhileCommon QuestionsAre we talking about SQL transactions?What about repeated Domain Logic?Are printing and echoing part of Domain Logic?Can a transaction be a class instead of a Method?What about Domain Logic in Gateway classes?What about Domain logic embedded in Non-Domain classes?
Review and next steps
10. Extract Presentation Logic to View Files
Embedded presentation logicThe Extraction processSearch for Embedded presentation logicRearrange the Page script and Spot CheckExtract Presentation to View file and Spot CheckCreate a views/ DirectoryPick a View File nameMove Presentation Block to View fileAdd Proper EscapingWrite View File TestsThe tests/views/ directoryWriting a View File TestAsserting Correctness Of ContentCommit, Push, Notify QADo ... WhileCommon QuestionsWhat about Headers and Cookies?What if we already have a Template system?What about Streaming Content?What if we have lots of Presentation variables?What about class methods that generate output?What about Business Logic Mixed into the presentation?What if a page contains only presentation logic?
Review and next steps
11. Extract Action Logic to Controllers
Embedded action logicThe Extraction ProcessSearch for Embedded Action LogicRearrange the Page Script and Spot CheckIdentify Code BlocksMove Code to Its Related BlockSpot Check the Rearranged CodeExtract a Controller ClassPick a Class NameCreate a Skeleton Class FileMove the Action Logic and Spot CheckConvert Controller to Dependency Injection and Spot CheckWrite a Controller TestCommit, Push, Notify QADo ... WhileCommon QuestionsCan we pass parameters to the Controller method?Can a Controller have Multiple actions?What If the Controller contains include Calls?
Review and next steps
12. Replace Includes in Classes
Embedded include Calls
The Replacement process
Search for include CallsReplacing a Single include CallReplacing Multiple include CallsCopy include file to Class MethodReplace the original include CallDiscover coupled variables through testingReplace other include Calls and TestDelete the include file and testWrite a test and refactorConvert to Dependency Injection and testCommit, Push, Notify QADo ... WhileCommon QuestionsCan one class receive logic from many include files?What about include calls originating in non-class files?
Review and next steps
13. Separate Public and Non-Public Resources
Intermingled resources
The separation process
Coordinate with operations personnelCreate a document root directoryReconfigure the serverMove public resourcesCommit, push, coordinate
Common Questions
Is This Really Necessary?
Review and next steps
14. Decouple URL Paths from File Paths
Coupled PathsThe Decoupling ProcessCoordinate with OperationsAdd a Front ControllerCreate a pages/ DirectoryReconfigure the ServerSpot checkMove Page scriptsCommit, Push, CoordinateCommon QuestionsDid we really Decouple the Paths?
Review and next steps
15. Remove Repeated Logic in Page Scripts
Repeated logicThe Removal ProcessModify the Front controllerRemove Logic from Page ScriptsSpot Check, Commit, Push, Notify QACommon QuestionsWhat if the Setup Work Is Inconsistent?What if we used inconsistent naming?
Review and next steps
16. Add a Dependency Injection Container
What is a Dependency Injection Container?Adding a DI ContainerAdd a DI Container Include FileAdd a Router ServiceModify the Front ControllerExtract Page Scripts to ServicesCreate a Container ServiceRoute the URL Path to the Container ServiceSpot Check and CommitDo ... WhileRemove pages/, Commit, Push, Notify QACommon QuestionsHow can we refine our service definitions?What if there are includes In the Page Script?Can we reduce the size of the services.php file?Can we reduce the size of the router service?What if we cannot update to PHP 5.3?
Review and next steps
17. Conclusion
Opportunities for improvement
Conversion to Framework
Review and next steps
A. Typical Legacy Page Script
B. Code before Gateways
C. Code after Gateways
D. Code after Transaction Scripts
E. Code before Collecting Presentation Logic
F. Code after Collecting Presentation Logic
G. Code after Response View File
H. Code after Controller Rearrangement
I. Code after Controller Extraction
J. Code after Controller Dependency Injection
Index

Content preview from Modernizing Legacy Applications in PHP

The separation process

Although the process itself is straightforward, the change we are making is a foundational one. It affects the server configuration as well as the legacy application structure. To fully effect this change, we will need to coordinate closely with any operations personnel who are in charge of server deployments.

In general, the process is as follows:

Coordinate with operations to communicate our intentions.
Create a new document root directory in our legacy application, along with a temporary index file.
Reconfigure the server to point to the new document root directory, and spot check the new configuration to see if our temporary index file appears.
Remove the temporary index file, then move all public resources to the new document ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781787124707

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Modernizing Legacy Applications in PHP

by Paul Jones

The separation process

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.