Zend Framework教程之响应对象的封装Zend_Controller_Response实例详解

abstract class zend_controller_response_abstract
{
 /**
  * body content
  * @var array
  */
 protected $_body = array();
 /**
  * exception stack
  * @var exception
  */
 protected $_exceptions = array();
 /**
  * array of headers. each header is an array with keys 'name' and 'value'
  * @var array
  */
 protected $_headers = array();
 /**
  * array of raw headers. each header is a single string, the entire header to emit
  * @var array
  */
 protected $_headersraw = array();
 /**
  * http response code to use in headers
  * @var int
  */
 protected $_httpresponsecode = 200;
 /**
  * flag; is this response a redirect?
  * @var boolean
  */
 protected $_isredirect = false;
 /**
  * whether or not to render exceptions; off by default
  * @var boolean
  */
 protected $_renderexceptions = false;
 /**
  * flag; if true, when header operations are called after headers have been
  * sent, an exception will be raised; otherwise, processing will continue
  * as normal. defaults to true.
  *
  * @see cansendheaders()
  * @var boolean
  */
 public $headerssentthrowsexception = true;
 /**
  * normalize a header name
  *
  * normalizes a header name to x-capitalized-names
  *
  * @param string $name
  * @return string
  */
 protected function _normalizeheader($name)
 {
  $filtered = str_replace(array('-', '_'), ' ', (string) $name);
  $filtered = ucwords(strtolower($filtered));
  $filtered = str_replace(' ', '-', $filtered);
  return $filtered;
 }
 /**
  * set a header
  *
  * if $replace is true, replaces any headers already defined with that
  * $name.
  *
  * @param string $name
  * @param string $value
  * @param boolean $replace
  * @return zend_controller_response_abstract
  */
 public function setheader($name, $value, $replace = false)
 {
  $this->cansendheaders(true);
  $name = $this->_normalizeheader($name);
  $value = (string) $value;
  if ($replace) {
   foreach ($this->_headers as $key => $header) {
    if ($name == $header['name']) {
     unset($this->_headers[$key]);
    }
   }
  }
  $this->_headers[] = array(
   'name' => $name,
   'value' => $value,
   'replace' => $replace
  );
  return $this;
 }
 /**
  * set redirect url
  *
  * sets location header and response code. forces replacement of any prior
  * redirects.
  *
  * @param string $url
  * @param int $code
  * @return zend_controller_response_abstract
  */
 public function setredirect($url, $code = 302)
 {
  $this->cansendheaders(true);
  $this->setheader('location', $url, true)
    ->sethttpresponsecode($code);
  return $this;
 }
 /**
  * is this a redirect?
  *
  * @return boolean
  */
 public function isredirect()
 {
  return $this->_isredirect;
 }
 /**
  * return array of headers; see {@link $_headers} for format
  *
  * @return array
  */
 public function getheaders()
 {
  return $this->_headers;
 }
 /**
  * clear headers
  *
  * @return zend_controller_response_abstract
  */
 public function clearheaders()
 {
  $this->_headers = array();
  return $this;
 }
 /**
  * clears the specified http header
  *
  * @param string $name
  * @return zend_controller_response_abstract
  */
 public function clearheader($name)
 {
  if (! count($this->_headers)) {
   return $this;
  }
  foreach ($this->_headers as $index => $header) {
   if ($name == $header['name']) {
    unset($this->_headers[$index]);
   }
  }
  return $this;
 }
 /**
  * set raw http header
  *
  * allows setting non key => value headers, such as status codes
  *
  * @param string $value
  * @return zend_controller_response_abstract
  */
 public function setrawheader($value)
 {
  $this->cansendheaders(true);
  if ('location' == substr($value, 0, 8)) {
   $this->_isredirect = true;
  }
  $this->_headersraw[] = (string) $value;
  return $this;
 }
 /**
  * retrieve all {@link setrawheader() raw http headers}
  *
  * @return array
  */
 public function getrawheaders()
 {
  return $this->_headersraw;
 }
 /**
  * clear all {@link setrawheader() raw http headers}
  *
  * @return zend_controller_response_abstract
  */
 public function clearrawheaders()
 {
  $this->_headersraw = array();
  return $this;
 }
 /**
  * clears the specified raw http header
  *
  * @param string $headerraw
  * @return zend_controller_response_abstract
  */
 public function clearrawheader($headerraw)
 {
  if (! count($this->_headersraw)) {
   return $this;
  }
  $key = array_search($headerraw, $this->_headersraw);
  if ($key !== false) {
   unset($this->_headersraw[$key]);
  }
  return $this;
 }
 /**
  * clear all headers, normal and raw
  *
  * @return zend_controller_response_abstract
  */
 public function clearallheaders()
 {
  return $this->clearheaders()
     ->clearrawheaders();
 }
 /**
  * set http response code to use with headers
  *
  * @param int $code
  * @return zend_controller_response_abstract
  */
 public function sethttpresponsecode($code)
 {
  if (!is_int($code) || (100 > $code) || (599 < $code)) {
   require_once 'zend/controller/response/exception.php';
   throw new zend_controller_response_exception('invalid http response code');
  }
  if ((300 <= $code) && (307 >= $code)) {
   $this->_isredirect = true;
  } else {
   $this->_isredirect = false;
  }
  $this->_httpresponsecode = $code;
  return $this;
 }
 /**
  * retrieve http response code
  *
  * @return int
  */
 public function gethttpresponsecode()
 {
  return $this->_httpresponsecode;
 }
 /**
  * can we send headers?
  *
  * @param boolean $throw whether or not to throw an exception if headers have been sent; defaults to false
  * @return boolean
  * @throws zend_controller_response_exception
  */
 public function cansendheaders($throw = false)
 {
  $ok = headers_sent($file, $line);
  if ($ok && $throw && $this->headerssentthrowsexception) {
   require_once 'zend/controller/response/exception.php';
   throw new zend_controller_response_exception('cannot send headers; headers already sent in ' . $file . ', line ' . $line);
  }
  return !$ok;
 }
 /**
  * send all headers
  *
  * sends any headers specified. if an {@link sethttpresponsecode() http response code}
  * has been specified, it is sent with the first header.
  *
  * @return zend_controller_response_abstract
  */
 public function sendheaders()
 {
  // only check if we can send headers if we have headers to send
  if (count($this->_headersraw) || count($this->_headers) || (200 != $this->_httpresponsecode)) {
   $this->cansendheaders(true);
  } elseif (200 == $this->_httpresponsecode) {
   // haven't changed the response code, and we have no headers
   return $this;
  }
  $httpcodesent = false;
  foreach ($this->_headersraw as $header) {
   if (!$httpcodesent && $this->_httpresponsecode) {
    header($header, true, $this->_httpresponsecode);
    $httpcodesent = true;
   } else {
    header($header);
   }
  }
  foreach ($this->_headers as $header) {
   if (!$httpcodesent && $this->_httpresponsecode) {
    header($header['name'] . ': ' . $header['value'], $header['replace'], $this->_httpresponsecode);
    $httpcodesent = true;
   } else {
    header($header['name'] . ': ' . $header['value'], $header['replace']);
   }
  }
  if (!$httpcodesent) {
   header('http/1.1 ' . $this->_httpresponsecode);
   $httpcodesent = true;
  }
  return $this;
 }
 /**
  * set body content
  *
  * if $name is not passed, or is not a string, resets the entire body and
  * sets the 'default' key to $content.
  *
  * if $name is a string, sets the named segment in the body array to
  * $content.
  *
  * @param string $content
  * @param null|string $name
  * @return zend_controller_response_abstract
  */
 public function setbody($content, $name = null)
 {
  if ((null === $name) || !is_string($name)) {
   $this->_body = array('default' => (string) $content);
  } else {
   $this->_body[$name] = (string) $content;
  }
  return $this;
 }
 /**
  * append content to the body content
  *
  * @param string $content
  * @param null|string $name
  * @return zend_controller_response_abstract
  */
 public function appendbody($content, $name = null)
 {
  if ((null === $name) || !is_string($name)) {
   if (isset($this->_body['default'])) {
    $this->_body['default'] .= (string) $content;
   } else {
    return $this->append('default', $content);
   }
  } elseif (isset($this->_body[$name])) {
   $this->_body[$name] .= (string) $content;
  } else {
   return $this->append($name, $content);
  }
  return $this;
 }
 /**
  * clear body array
  *
  * with no arguments, clears the entire body array. given a $name, clears
  * just that named segment; if no segment matching $name exists, returns
  * false to indicate an error.
  *
  * @param string $name named segment to clear
  * @return boolean
  */
 public function clearbody($name = null)
 {
  if (null !== $name) {
   $name = (string) $name;
   if (isset($this->_body[$name])) {
    unset($this->_body[$name]);
    return true;
   }
   return false;
  }
  $this->_body = array();
  return true;
 }
 /**
  * return the body content
  *
  * if $spec is false, returns the concatenated values of the body content
  * array. if $spec is boolean true, returns the body content array. if
  * $spec is a string and matches a named segment, returns the contents of
  * that segment; otherwise, returns null.
  *
  * @param boolean $spec
  * @return string|array|null
  */
 public function getbody($spec = false)
 {
  if (false === $spec) {
   ob_start();
   $this->outputbody();
   return ob_get_clean();
  } elseif (true === $spec) {
   return $this->_body;
  } elseif (is_string($spec) && isset($this->_body[$spec])) {
   return $this->_body[$spec];
  }
  return null;
 }
 /**
  * append a named body segment to the body content array
  *
  * if segment already exists, replaces with $content and places at end of
  * array.
  *
  * @param string $name
  * @param string $content
  * @return zend_controller_response_abstract
  */
 public function append($name, $content)
 {
  if (!is_string($name)) {
   require_once 'zend/controller/response/exception.php';
   throw new zend_controller_response_exception('invalid body segment key ("' . gettype($name) . '")');
  }
  if (isset($this->_body[$name])) {
   unset($this->_body[$name]);
  }
  $this->_body[$name] = (string) $content;
  return $this;
 }
 /**
  * prepend a named body segment to the body content array
  *
  * if segment already exists, replaces with $content and places at top of
  * array.
  *
  * @param string $name
  * @param string $content
  * @return void
  */
 public function prepend($name, $content)
 {
  if (!is_string($name)) {
   require_once 'zend/controller/response/exception.php';
   throw new zend_controller_response_exception('invalid body segment key ("' . gettype($name) . '")');
  }
  if (isset($this->_body[$name])) {
   unset($this->_body[$name]);
  }
  $new = array($name => (string) $content);
  $this->_body = $new + $this->_body;
  return $this;
 }
 /**
  * insert a named segment into the body content array
  *
  * @param string $name
  * @param string $content
  * @param string $parent
  * @param boolean $before whether to insert the new segment before or
  * after the parent. defaults to false (after)
  * @return zend_controller_response_abstract
  */
 public function insert($name, $content, $parent = null, $before = false)
 {
  if (!is_string($name)) {
   require_once 'zend/controller/response/exception.php';
   throw new zend_controller_response_exception('invalid body segment key ("' . gettype($name) . '")');
  }
  if ((null !== $parent) && !is_string($parent)) {
   require_once 'zend/controller/response/exception.php';
   throw new zend_controller_response_exception('invalid body segment parent key ("' . gettype($parent) . '")');
  }
  if (isset($this->_body[$name])) {
   unset($this->_body[$name]);
  }
  if ((null === $parent) || !isset($this->_body[$parent])) {
   return $this->append($name, $content);
  }
  $ins = array($name => (string) $content);
  $keys = array_keys($this->_body);
  $loc = array_search($parent, $keys);
  if (!$before) {
   // increment location if not inserting before
   ++$loc;
  }
  if (0 === $loc) {
   // if location of key is 0, we're prepending
   $this->_body = $ins + $this->_body;
  } elseif ($loc >= (count($this->_body))) {
   // if location of key is maximal, we're appending
   $this->_body = $this->_body + $ins;
  } else {
   // otherwise, insert at location specified
   $pre = array_slice($this->_body, 0, $loc);
   $post = array_slice($this->_body, $loc);
   $this->_body = $pre + $ins + $post;
  }
  return $this;
 }
 /**
  * echo the body segments
  *
  * @return void
  */
 public function outputbody()
 {
  $body = implode('', $this->_body);
  echo $body;
 }
 /**
  * register an exception with the response
  *
  * @param exception $e
  * @return zend_controller_response_abstract
  */
 public function setexception(exception $e)
 {
  $this->_exceptions[] = $e;
  return $this;
 }
 /**
  * retrieve the exception stack
  *
  * @return array
  */
 public function getexception()
 {
  return $this->_exceptions;
 }
 /**
  * has an exception been registered with the response?
  *
  * @return boolean
  */
 public function isexception()
 {
  return !empty($this->_exceptions);
 }
 /**
  * does the response object contain an exception of a given type?
  *
  * @param string $type
  * @return boolean
  */
 public function hasexceptionoftype($type)
 {
  foreach ($this->_exceptions as $e) {
   if ($e instanceof $type) {
    return true;
   }
  }
  return false;
 }
 /**
  * does the response object contain an exception with a given message?
  *
  * @param string $message
  * @return boolean
  */
 public function hasexceptionofmessage($message)
 {
  foreach ($this->_exceptions as $e) {
   if ($message == $e->getmessage()) {
    return true;
   }
  }
  return false;
 }
 /**
  * does the response object contain an exception with a given code?
  *
  * @param int $code
  * @return boolean
  */
 public function hasexceptionofcode($code)
 {
  $code = (int) $code;
  foreach ($this->_exceptions as $e) {
   if ($code == $e->getcode()) {
    return true;
   }
  }
  return false;
 }
 /**
  * retrieve all exceptions of a given type
  *
  * @param string $type
  * @return false|array
  */
 public function getexceptionbytype($type)
 {
  $exceptions = array();
  foreach ($this->_exceptions as $e) {
   if ($e instanceof $type) {
    $exceptions[] = $e;
   }
  }
  if (empty($exceptions)) {
   $exceptions = false;
  }
  return $exceptions;
 }
 /**
  * retrieve all exceptions of a given message
  *
  * @param string $message
  * @return false|array
  */
 public function getexceptionbymessage($message)
 {
  $exceptions = array();
  foreach ($this->_exceptions as $e) {
   if ($message == $e->getmessage()) {
    $exceptions[] = $e;
   }
  }
  if (empty($exceptions)) {
   $exceptions = false;
  }
  return $exceptions;
 }
 /**
  * retrieve all exceptions of a given code
  *
  * @param mixed $code
  * @return void
  */
 public function getexceptionbycode($code)
 {
  $code  = (int) $code;
  $exceptions = array();
  foreach ($this->_exceptions as $e) {
   if ($code == $e->getcode()) {
    $exceptions[] = $e;
   }
  }
  if (empty($exceptions)) {
   $exceptions = false;
  }
  return $exceptions;
 }
 /**
  * whether or not to render exceptions (off by default)
  *
  * if called with no arguments or a null argument, returns the value of the
  * flag; otherwise, sets it and returns the current value.
  *
  * @param boolean $flag optional
  * @return boolean
  */
 public function renderexceptions($flag = null)
 {
  if (null !== $flag) {
   $this->_renderexceptions = $flag ? true : false;
  }
  return $this->_renderexceptions;
 }
 /**
  * send the response, including all headers, rendering exceptions if so
  * requested.
  *
  * @return void
  */
 public function sendresponse()
 {
  $this->sendheaders();
  if ($this->isexception() && $this->renderexceptions()) {
   $exceptions = '';
   foreach ($this->getexception() as $e) {
    $exceptions .= $e->__tostring() . "\n";
   }
   echo $exceptions;
   return;
  }
  $this->outputbody();
 }
 /**
  * magic __tostring functionality
  *
  * proxies to {@link sendresponse()} and returns response value as string
  * using output buffering.
  *
  * @return string
  */
 public function __tostring()
 {
  ob_start();
  $this->sendresponse();
  return ob_get_clean();
 }
}

/** zend_controller_response_abstract */
require_once 'zend/controller/response/abstract.php';
/**
 * zend_controller_response_http
 *
 * http response for controllers
 *
 * @uses zend_controller_response_abstract
 * @package zend_controller
 * @subpackage response
 */
class zend_controller_response_http extends zend_controller_response_abstract
{
}

$response->sendresponse();

$front->returnresponse(true);
$response = $front->dispatch();
// do some more processing, such as logging...
// and then send the output:
$response->sendresponse();

// within an action controller action:
// set a header
$this->getresponse()
 ->setheader('content-type', 'text/html')
 ->appendbody($content);

// retrieve post-dispatch:
$front->dispatch();
$response = $front->getresponse();
if ($response->isexception()) {
 // log, mail, etc...
}
// or, have the front controller dispatch() process return it
$front->returnresponse(true);
$response = $front->dispatch();
// do some processing...
// finally, echo the response
$response->sendresponse();

$response->renderexceptions(true);
$front->dispatch($request, $response);
// or:
$front->returnresponse(true);
$response = $front->dispatch();
$response->renderexceptions();
$response->sendresponse();
// or:
$front->throwexceptions(true);
$front->dispatch();

// assume that this plugin class is registered with the front controller
class myplugin extends zend_controller_plugin_abstract
{
 public function predispatch(zend_controller_request_abstract $request)
 {
  $response = $this->getresponse();
  $view = new zend_view();
  $view->setbasepath('../views/scripts');
  $response->prepend('header', $view->render('header.phtml'));
 }
 public function postdispatch(zend_controller_request_abstract $request)
 {
  $response = $this->getresponse();
  $view = new zend_view();
  $view->setbasepath('../views/scripts');
  $response->append('footer', $view->render('footer.phtml'));
 }
}
// a sample action controller
class mycontroller extends zend_controller_action
{
 public function fooaction()
 {
  $this->render();
 }
}

array(
 'header' => ..., // header content
 'default' => ..., // body content from mycontroller::fooaction()
 'footer' => ... // footer content
);