The php anthology 2nd edition 2007 - phần 9 pps

Now, let’s build the XML-RPC server, and for good measure, let’s also create a function for retrieving XML-RPC server information: $server = new Zend_XmlRpc_Server; // Math class method

Trang 1

created phpDocumentor docblocks describing the functions or class methods,14 to determine the XML-RPC prototypes The caveat to using this approach is that you must use XML-RPC types in your docblocks to describe your parameters and return values

Zend_XmlRpc_Server, like all server classes in the Zend Framework, follows PHP’s SoapServerAPI, which makes the interface consistent across the different protocol implementations

As an example, here’s a simple Math class with two methods, add and multiply,

for which we can build a server:

Trang 2

Now, let’s build the XML-RPC server, and for good measure, let’s also create a

function for retrieving XML-RPC server information:

$server = new Zend_XmlRpc_Server();

// Math class methods will be available in the 'math' namespace

You will need to write phpDocumentor docblocks for each method or function you’ll

be serving, and ensure they contain @param and @return tags; the server uses these

to create the method signatures, and compares the types and numbers of incoming parameters with those signatures to ensure the incoming request conforms to the definition Additionally, the types specified with these tags should conform to XMLSimpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com

Trang 3

RPC type definitions; for example, use struct for associative arrays,

date-Time.iso8601 for dates, and so on

PHP’s Native XML-RPC Extension

Serving XML-RPC with Zend_XmlRpc_Server is as easy as serving SOAP requests

in PHP 5; simply register a class or function with the server, and handle it But be

sides Zend_XmlRpc_Server, what options do we have?

ext/xmlrpc can be used to build XML-RPC servers, too We simply create an XML

RPC server using xmlrpc_server_create, register callbacks to XML-RPC method

names, grab the request, handle it, and send the response back As an example, let’s try to serve the following method and function:

* @param string $method The XML-RPC method name called

* @param array $params Array of parameters from the request

Trang 4

Now that we’ve created these definitions, we’ll register them with the XML-RPC server:

ext_xmlrpc_serv.php (excerpt)

$server = xmlrpc_server_create();

xmlrpc_server_register_method($server, 'math.add', array('Math',

'add'));

xmlrpc_server_register_method($server, 'product', 'product');

Now we need to grab the request, dispatch it, and return a response:

The easier approach is to use an XML-RPC server that creates this magic for you PEAR’s XML_RPC2 and Zend_XmlRpc are two such implementations Zend_XmlRpc makes XML-RPC a first-class OOP citizen, simplifying the process of making requests and serving responses, and allowing any function or class method to be used as a server handler

How can I consume SOAP web services?

SOAP, originally an acronym for Simple Object Access Protocol, but now simply a

protocol name, is, to quote the specification, “a lightweight protocol intended for exchanging structured information in a decentralized, distributed environment.” SOAP provides tremendous flexibility and extensibility

Simpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com

Trang 5

Like the other protocols discussed in this section, SOAP uses XML to transfer

messages between the client and server The base message unit that’s transferred is

an object A server needs to specify the available methods and properties, and make that specification available to clients so that they can initiate requests This specific

ation is achieved using a WSDL, the Web Services Description Language, specifica

tion

The SOAP and WSDL specifications are notoriously difficult to decipher The gen

eral consensus among developers is to use WSDL development tools to create the

WSDL from your application classes, and to use clients and servers provided in

your language to conduct the actual SOAP communication Fortunately, PHP 5 has native SoapClient and SoapServer classes, and tools are emerging for generating

the WSDL

The topic of consuming SOAP-based web services is incredibly broad and we

couldn’t possibly cover it in any great detail in this book, but here’s a gentle intro

duction

Solution

Using the PHP 5 SoapClient class is incredibly easy:

There’s certainly much more to the SoapClient class, but that’s the basic usage:

create a SoapClient instance by passing the URL to the WSDL specification, and

the location of the SOAP service, as arguments to the SoapClient constructor, and start making calls The SoapClient makes all the methods of the SOAP service

available as PHP methods

What if you want to pull the results of a SOAP request into an object? No problem! You can easily map a SOAP response to a PHP class Here’s a hypothetical example that uses a book information service The SOAP service provides a getBookInfo

method If we pass it an $id value, it will return a response representing a book

with author, title, date, and publisher properties This response is defined in

the web service’s WSDL file as the type Book And if we already have an object for Simpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com

Trang 6

a book in our PHP application (let’s call it MyBook), we can map the SOAP responsetype onto our own MyBook object First, we define our MyBook class:

When it binds a class to a SOAP response, SoapClient will set in the object any

public properties for which it finds a match in the response Because the returnedobject instance is a standard PHP object, you can also define methods for accessing

or transforming the SOAP data in the class

Discussion

Assuming that the remote service has a defined WSDL specification, making requests

to SOAP services is tremendously easy in PHP 5 The flexibility to bind objects toresponses can offer tremendous opportunities for working with remote data If

you’ve been afraid of SOAP before, yet you’re comfortable with OOP, there’s no

need to be afraid any longer!

Trang 7

How do I serve SOAP web services?

You’ve dipped your toes in the SOAPy water by consuming some SOAP services

in “How can I consume SOAP web services?”, and now you’re thinking that the

next step is to create some of your own You’ve got a number of classes that seem

eligible; how can you expose their APIs publicly?

Solution

Serving SOAP is roughly as easy as the using the client: use SoapServer The topic

of creating SOAP-based web services is another broad area that we couldn’t possibly cover in any great detail in this book, but let’s get our bearings by looking a simple example

First, let’s define a class for a book with the original name of Book:

Trang 8

⋮ perform some work and get some book details…

$book = new Book($author, $title, $date, $publisher);

return $book;

}

Now let’s bind these classes to a SoapServer instance:

$server = new SoapServer($uriToWsdl, array(

Serving SOAP has never been so easy as it is with PHP 5 But there’s one more aspect

to consider: what about the WSDL specification?

It’s possible to use SOAP between PHP servers without using WSDL, but this proach is problematic, because it means that many of the features of the SOAP client,such as the auto-discovery of available methods, won’t work It then becomes theresponsibility of the service developer to communicate the available methods to

ap-those consuming the services Although generating your own WDSL may be a

daunting task, given the complexity of the specification, many IDEs have tools forgenerating WSDL specifications based on the introspection of your classes AnotherSimpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com

Trang 9

choice for generating WSDL specifications, and a newcomer on the scene, is

Zend_Soap, from the Zend Framework.15 This component contains the

Zend_Soap_AutoDiscover class, which will generate a WSDL specification from a

class using PHP’s own Reflection API Here’s an example:

From here, you can cache the generated WSDL specification, contained in the $wsdl variable, in a web-accessible location, then start to create servers and clients for it

using SoapServer and SoapClient

How can I consume REST services?

REST, or Representational State Transfer, is a newcomer on the web services scene,

and has gained considerable popularity in the past few years The ideas behind this architectural approach are simple: application state and functionality are separated into resources that can be addressed with a unique identifier, all resources share a consistent interface and standardized content types As it happens, the Web is a

great example of this style of application architecture We can use the URL as the

unique identifier for resources and the HTTP protocol as the consistent interface

through which we access the resources Finally, resources are represented by

standardized content types—XML, HTML, and so on.16

As an example, let’s consider a hypothetical REST service for books:

■ A GET request to http://example.com/books uses XML to return a list of books

■ A POST request that contains XML book data and is made to the same URL will add a new book to the service

■ Retrieving the XML for an individual book involves making an HTTP GETrequest

to a slightly different URL that specifies a particular resource, such as

Trang 10

■ Editing the book involves sending XML book data via an HTTP PUT request to the same URL

■ Sending an HTTP DELETE request to the URL would delete the resource

Such a service would be considered RESTful, that is, it would follow the principles

of REST Each resource has a unique identifier, its URL, and each resource has a consistent interface, HTTP, through which the request type describes the type of action being requested

Basically, REST makes use of the technology of the Web, unlike XMLRPC or SOAP, which use the Web simply as a means for sending commands For example, in our REST API above, sending a GET request to http://example.com/books/php-anthology returns the XML representation of the book If the book doesn’t exist, the service responds with a standard HTTP 404 Not Found response In contrast, using an

XMLRPC interface to the same service might require you open a connection to the service and make a method call to a getBookmethod, passing the book’s identifying code, php-anthology, as an argument If the book didn’t exist, the service would respond with an error message The main difference between these two approaches

is the use of HTTP to represent the intended action—GETting a book—and the

meaningful URL that represents the book itself

In real-world circumstances, many browsers and HTTP clients still don’t implement PUT and DELETE, so all resource update and delete operations are completed via

POST requests that use additional request parameters to represent the operation desired While not entirely RESTful, the practice is widespread enough to be considered the standard approach

Modern REST services that use XML are common Some REST services provide

XML schemas so that consumers can easily determine how to get at the data they need or format their requests, while others simply provide API documentation

Solution

By now, you should be well on your way to being able to handle any XML that’s thrown at you We can use SimpleXML to parse REST responses, and SimpleXML, DOM, or XMLWriter to create requests (if a data payload is needed)

Trang 11

To use a specific REST service, you’ll need to obtain its API documentation, but for the purposes of this example, let’s use the hypothetical REST service for books we defined above Let’s assume that the URL http://example.com/books, when called

via an HTTP GET request, returns the following XML list of books:

In our book service, the id attribute of each book can be used to retrieve the book’s details Here’s an example of the XML returned by a GET request to

Trang 12

For XML-based REST services, we can employ SimpleXML to do the heavy lifting

of making the request, receiving the response, and parsing it In the example above,

we retrieve the books list by instantiating a new SimpleXMLElement object, passing the URL as the first argument If the first argument to the constructor is a URL, the third argument must be true We grab the id attribute values of all books, and use them to make new requests to obtain the XML data for each book We then grab

each book’s title and publisher in order to display the list

How would you create a new book using this service? Most services would have you POST a book definition to the base URL, and in our example, that approach

might look like this:

The task of editing a particular resource would be similar to that of adding a new document However, the URL we’ll use will be the resource’s unique URL, and instead of sending the entire book definition, we’ll need to send only the data that’s changing:

Trang 13

Maybe we want to delete the book from the list—how would we accomplish this?

So far, we’ve distinguished between adding and updating resources by changing

the URL A proper RESTful web service would have us send an HTTP DELETErequest

to the book’s unique URL, but since not all HTTP clients can generate DELETE re

quests, our web service does the next best thing: it requires users to POST a delete element with a value of 1:

The example above is a bit contrived, but it’s not far off the mark A client makes

simple HTTP GETrequests to resources, and decides what to do with the responses,

or POSTs XML to the service in order to add, update, or delete resources SimpleXML

is the staple resource for consuming and generating requests, and PHP’s own streams layer makes POSTing requests a breeze

In a real REST service, you’ll need to examine the API carefully to determine which URLs are available, what XML they return, and what XML they expect for operations that affect data in the service REST is loosely defined, so each time you want to

interact directly with a new REST service, you’ll need to do a bit of learning

Trang 14

Using the Zend Framework

Another possible approach to consuming a REST service is to use Zend Framework’s Zend_Rest_Clientcomponent.17 This client expects that the REST server it contacts

is using XML for the transaction, which should be a safe assumption After performing the request, we access the response using object properties, which eliminates the need to perform type casting as we must with SimpleXML

Technorati’s bloginfo API requires you to make a GET request to the following

Trang 15

As an example, you could use the following approach to use Technorati’s bloginfo service:

zend_rest_technorati.php (excerpt)

require_once 'Zend\Rest\client.php';

$key = apikey; // Technorati requires an API key

$technorati = new Zend_Rest_Client(

How can I serve REST services?

You’re jumping on the REST bandwagon Your boss is convinced that this is the

big new trend in web services, and wants something out the door today What do

you need to do?

Solution

Honestly, all you need to do is:

■ Create URLs or a URL schema that can map to your resources

■ Create XML for your responses

You need to determine which resources you’ll make available, and then come up

with a URL schema to cover them In this example, let’s use books as the resource

Trang 16

we want to make available Perhaps you need services that allow you to list the

book resources, detail a single book at a time, and allow users to post information about new books and edit that for existing books

A RESTful URL schema might look like this:

■ retrieve list of books: http://example.com/books

■ retrieve single book: http://example.com/books/book-name

To add a book, you would POST to the first URL; to update the details of an existing book, you would POSTto the second Next, you need to create a script to handle the incoming requests Make sure you have a look at “How do I make “pretty” URLs in PHP?” in Chapter 5—there, you’ll find a complete solution for creating a URL schema with the Apache web server and a request handling class Here’s a simple example script to handle our book requests:

⋮ new book entry

⋮ list books

⋮ edit book entry

⋮ retrieve book entry

This script starts by exploding the path information of the incoming request into

an array, and trimming the trailing / character It then tests how many elements are Simpo PDF Merge and Split Unregistered Version - http://www.simpopdf.com

Trang 17

generated, and whether the first element is books If only one element is present,

books, the script checks the request method If it’s a POST request, the code takes

the branch to creating a new book; if it’s a GET request, the code takes the branch to listing all the books

If two elements are present, the script assumes that the second element is the book name In this case, a POST request represents an update to the specific book and a

GET request will display the named book

For the book list and named-book information requests, simply generate or fetch

the XML to return to the user In the case of new entries or updated entries, you’ll

need to retrieve and parse the incoming XML first To retrieve the incoming XML,

grab it from the raw POST request like this:

Once you have the XML, you can parse and act on it as necessary

is usually served much faster than dynamic content by modern web servers

While REST services scale well and are relatively easy to implement, they do make the job more difficult for developers who want to use your services, since developers need to learn a new XML schema for every new REST service they consume How

ever, the simplicity of dealing with XML in PHP 5 makes this a moot point in most regards, and the combination of REST and SimpleXMLmakes for some very powerful web services, both on the client and server ends

Summary

In this chapter, we’ve taken a quick tour of PHP 5’s various XML and web service

extensions We discussed the tasks of parsing and generating XML and using RSS

Trang 18

feeds, concluding that SimpleXML is PHP 5’s Swiss Army Knife for XML manipulation, but also noting other important extensions such as SAX, XMLReader,

XMLWriter, and DOM (on which SimpleXML is based) Searching XML via XPath, using both DOM and SimpleXML, was demonstrated, and the basic XPath syntax was covered

Most modern web services use XML for their payloads XML-RPC uses XML for

type hinting values passed in a request and returned in a response; with modern XML-RPC libraries such as Zend_XmlRpc, XML-RPC services can be called as PHP object methods transparently SOAP defines an object as the unit of transport, and PHP 5’s SoapServer and SoapClient classes make creating and consuming SOAP services trivial Finally, we discussed REST and RESTful web services, using SimpleXML to generate and consume REST resources

Trang 19

13

Best Practices

The fact that PHP has an incredibly low barrier to entry represents both its greatest

strength and greatest weakness To its merit, PHP allows the novice programmer to

develop feature-rich applications without needing to learn even the rudiments of

computer science The downside, however, is that as PHP offers many ways to

complete the same task, application code can quickly become unmaintainable

Many programmers in the PHP field are now recognizing the need to standardize

and promote best practices Some of these best practices are PHP specific, such as

the usage of tools like phpDocumentor for consistent documentation,1 or testing

suites such as SimpleTest2 and PHPUnit.3 Other practices that are being promoted

in the PHP community are more generic—the use of revision control systems and

code deployment practices, for example Regardless, if you follow all of them, these

practices will make your life—and the lives of those who may later maintain your

code—much easier

1 http://www.phpdoc.org/

2 http://simpletest.org/

3 http://www.phpunit.de/

Trang 20

How do I track revisions

of a project

Solution

My preferred RCS is Subversion, and this software will be used in all the examples throughout this chapter.5

So you need to undo your changes fast? If you haven’t already committed your

changes, you can roll them back easily with the following command:

If you’ve already committed your changes, the following command will undo them:

This command will revert your code to the previous version:

4

5

Trang 21

Discussion

A variety of versioning solutions is available, but they can be grouped into two

major categories: distributed and non-distributed systems

In distributed systems, each user maintains his or her own repository, and the

software typically tracks only changesets—software patches representing changes

to the files under version control Developers then share the changesets with one

another, usually maintaining one canonical repository with all the changesets that have been accepted into the project

In non-distributed systems, a repository resides on a central server Developers in

dividually check out the repository to their own working directories, and check in their changes as they’re completed

Both systems have their benefits and downsides However, non-distributed systems are more commonly used in PHP projects, so they’re the type you’ll most likely run into Having a central repository allows you to designate a single location for the

canonical version of the software you’re developing You can easily tie in processes

to run pre- and post-commit, perhaps performing unit tests, compiling documenta

tion, or sending commit notifications to a distribution list

As I mentioned, many revision control systems are available, in both proprietary

and open source forms The most popular open source packages, and arguably the most popular revision control systems, are Concurrent Versioning System (CVS)

and Subversion (SVN) The popularity of the two is, in large part, due to their open source nature; users obtain the tools for free, and can develop their own tools around these without needing to worry about license infringement Additionally, no propri

etary clients are necessary in order to work with these tools

CVS is the grandfather of non-distributed systems, and is the chosen revision control software for high-profile projects such as PHP itself and the PEAR project Subversion

is an evolution of CVS, and offers easier syntax for renaming files and directories

in a repository, committing entire directory trees, and branching and tagging This software is used in many modern frameworks, such as eZ Components and the Zend Framework

I personally recommend the use of Subversion for any new PHP projects, as its ease

of setup, simple processes for creating pre- and post-commit hook scripts, and in

Trang 22

tegration with other tool sets (IDEs and bug-tracking software, for example), are

unparalleled among RCNs Another advantage of Subversion is that the entire tree

is versioned—individual files don’t receive their own versions This feature allows you to make changes to multiple files as a distinct change set When checking in your code, you can check in a complete change—unit tests, code, and documentation—all in one go This style of versioning makes it easier later when you need to look through the log files to determine what changed and when, and which files were affected

How can I maintain multiple

versions of a single codebase?

Your project has just had a successful release, and now you need to support that release However, you’ve been hard at work and already have new changes you

want to introduce for the next release How can you maintain both code bases, and ensure important fixes in one are ported to the other?

Alternatively, perhaps you need to be able to continue development of your web site’s code base, but have a stable, production version of it running as well How can you keep the two versions separate?

Solution

Branching and tagging are features common to RCS, allowing you to maintain sep

arate branches of code in your repository A branch is a separate version of the

software that exists independently from other versions and maintains its own history

A tag is a named snapshot of the project at a given point in time

A typical repository layout should look something like this:

We create a branch for each release like so:

Trang 23

The use of Subversion allows this task to be completed very easily:

Later, if you need to create a point release—a minor version, especially one intended

to fix bugs rather than add new features—you can create an appropriate tag:

➥ tags/release-1.0.1 -m '1.0.1 bugfix release'

Similarly, you can create a branch for a production version of a site:

When you’re ready to deploy a software release, create a tag with a name that de

scribes the changes:

Discussion

In most cases, day-to-day development will occur in the repository trunk When

you’re ready to create a software release, create a branch From this point forward, changes in the trunk will not affect code in the release branch—unless you merge

them manually Branches provide code separation, which helps you to prevent new features or backward compatibility breaks from creeping into released code You

can also selectively merge bug fixes or new features from one branch to another

using your version control system’s merging capabilities Here’s how the merge

command would be used in Subversion, for instance:

Trang 24

However, an actual release needs to be static—that is, active development must

have stopped—and we achieve this with tagging

In Subversion, tags and branches are created in the same way—via the “copy” operation The only difference between them lies in the conventions that surround their use Branches should indicate ongoing development, such as bug fixes, new features, and the like; tags should be considered static snapshots

One aspect to note is that in Subversion, copies are achieved using hard links, and not actual file copies; new files are only created when a new version is checked in against the copy This means that copies are cheap, so you can—and should—branch and tag often

“Wait!" you say “I’m not developing software—I’m developing a web site! How

does this apply to me?” Easy now; you still need to be able to keep your development and production versions of the site separate, and your tags should represent points

at which you launch bug fixes or new features on the site:

On a day-to-day basis, you work in the repository trunk As you finish features or bug fixes, you merge them into the production branch You then preview this branch

on your staging server, which is almost identical to the production server—it may even use the same data, pulled from the same web services Once you’ve verified the changes, or your quality assurance team has reviewed the site and given its seal

of approval, you create a tag You can then export the project files from this tag:

Trang 25

➥ http://example.com/svn/project/tags/2006-09-19-PirateDayJargon

➥ 2006-09-19-PirateDayJargon

svn exportgrabs code from the repository and creates a local working copy without the versioning information (that is, the.svn subdirectories) This gives you a leaner, production-ready code tree to deploy

How can I write distributable code?

When you’re working in a team, or writing code that will be released to the public, you need to keep several points in mind:

■ Code should be easily reused and extended

■ Code should be easily readable

■ Code files should be easily found in the file system

Common problems developers run into when they’re working on others’ code, or

they’re using or extending third-party code, include:

■ difficulty extending code due to inflexible APIs (or lack of an API), or unclear

inheritance (for example, how do you extend procedural code?)

■ naming collisions as a result of poor naming practices such as using common

names when creating a class (for example, Mail)

■ difficulty reading other people’s code because of inconsistencies with indentation; variable, function, class, and file naming conventions; and code structure

These are obviously separate problems, but all are related to the problem of failing

to write distributable code

Solutions

Distributable code is all about adopting good habits There’s no single, bullet-proof solution to writing distributable code, but there are a few programming practices

you should adopt Turning them into programming habits will also mean that

writing distributable code will take no extra effort at all Let’s take a look at three

different programming practices you should consider

Trang 26

Using OOP

If you haven’t done so yet, make sure you read “What is OOP?” in Chapter 1 Object oriented programming (OOP) is often derided by performance experts as being very costly to an application’s performance.6 The counter-argument is that CPU cycles and memory are cheap, while developers are not OOP provides incredible benefits

to developers: object oriented code is very easily reused and extended, it’s typically easier to test because of the testing frameworks now available in PHP, it can reduce the number of naming collisions drastically, and it can lead to shorter syntax in

many cases Consider the following example:

or functions, and use either object in exactly the same way without needing to know which class it encapsulates:

6 For documentation of PHP 5’s OOP feature set, visit http://www.php.net/oop5/

Trang 27

If we wanted to achieve the same end using procedural functions, the equivalent

code might look like this:

The actual function call is certainly faster now that we don’t have to instantiate an object, although this benefit is moot with static methods The downside is that we can’t simply call foo_bar() and get the new behavior—we have to call an entirely different function

If we want to be able to dynamically call a method of our choosing elsewhere in

the application, we can’t hard-code the function call; instead, we need to pass a

function name or PHP callback This approach could decrease performance, and

also makes debugging and testing more difficult

Let’s also consider that we may well need to implement similar functionality, but

with radically different internals As an example, we might want to create two dif

ferent mail functions: one that sends email using the PHP mailfunction, and another that sends it via SMTP I’ve witnessed situations where both functions were named mailer, which led to naming conflicts later when both files were loaded simultan

eously If we incorporate these functions into classes instead, using, say My_Sendmail and My_Smtp as class names, we remove the conflict:

Định dạng
Số trang	55
Dung lượng	3 MB