Klasa Zend_Controller jest sercem systemu MVC
biblioteki Zend Framework. MVC oznacza Model-Widok-Kontroler
i jest wzorcem projektowym mającym na celu oddzielenie logiki
aplikacji od logiki wyświetlania. Klasa
Zend_Controller_Front implementuje wzorzec projektowy
kontrolera
frontowego. Wszystkie żądania są przechwytywane
przez kontroler frontowy i na podstawie adresu URL uruchamiany
jest odpowiedni kontroler akcji.
The Zend_Controller system was built with extensibility
in mind, either by subclassing the existing classes, writing new
classes that implement the various interfaces and abstract classes
that form the foundation of the controller family of classes, or
writing plugins or action helpers to augment or manipulate the
functionality of the system.
If you need more in-depth information, see the following sections. If you just want to get up and running quickly, read on.
Pierwszym krokiem jest utworzenie struktury katalogów. Typowa struktura wygląda w taki sposób:
application/
controllers/
IndexController.php
models/
views/
scripts/
index/
index.phtml
helpers/
filters/
html/
.htaccess
index.php
W swoim serwerze www, ustaw główną ścieżkę serwera na katalog
html znajdujący się w powyższej przykładowej
strukturze katalogów.
Zedytuj plik html/.htaccess aby wyglądał w taki
sposób:
RewriteEngine on
RewriteRule !\.(js|ico|gif|jpg|png|css)$ index.php
The above rules will route any non-resource (images, stylesheets) requests to the front controller. If there are other extensions you wish to exclude from the front controller (PDFs, text files, etc), add their extensions to the switch, or create your own rewrite rules.
Uwaga
Powyższe reguły przepisania przygotowane sa dla serwera Apache; aby zobaczyć przykładowe reguły dla innych serwerów, zobacz dokumentację routera.
Plik ładujący jest miejscem, przez którze przechodzą wszystkie
żądania -- w tym przypadku jest to -- html/index.php.
Otwórz plik html/index.php w dowolnym edytorze i
dodaj poniższy kod:
Zend_Controller_Front::run('/path/to/app/controllers');
Utworzy to egzemplarz kontrolera frontowego i go uruchomi, co spowoduje przekazanie żądań do kontrolerów akcji.
Before discussing action controllers, you should first
understand how requests are routed in Zend Framework. By
default, the first segment of a URL path maps to a controller,
and the second to an action. For example, given the URL
http://framework.zend.com/roadmap/components, the
path is /roadmap/components, which will map to the
controller roadmap and the action
components. If no action is provided, the action
index is assumed, and if no controller is provided,
the controller index is assumed (following the
Apache convention that maps a DirectoryIndex
automatically).
Zend_Controller's dispatcher then takes the
controller value and maps it to a class. By default, it
Title-cases the controller name and appends the word
Controller. Thus, in our example above, the
controller roadmap is mapped to the class
RoadmapController.
Similarly, the action value is mapped to a method of the
controller class. By default, the value is lower-cased, and the
word Action is appended. Thus, in our example
above, the action components becomes
componentsAction, and the final method called is
RoadmapController::componentsAction().
Idąc dalej, utwórzmy teraz domyślny kontroler akcji i metodę
akcji. Jak wspomniano wcześniej, domyślna nazwa kontrolera oraz
akcji to index. Otwórz w edytorze plik
application/controllers/IndexController.php, i
dodaj poniższy kod:
class IndexController extends Zend_Controller_Action
{
public function indexAction()
{
}
}
By default, the ViewRenderer
action helper is enabled. What this means is that by simply
defining an action method and a corresponding view script, you
will immediately get content rendered. By default,
Zend_View is used as the View layer in the MVC. The
ViewRenderer does some magic, and uses the
controller name (e.g., index) and the current
action name (e.g., index) to determine what
template to pull. By default, templates end in the
.phtml extension, so this means that, in the above
example, the template index/index.phtml will be
rendered. Additionally, the ViewRenderer
automatically assumes that the directory views at
the same level as the controller directory will be the base view
directory, and that the actual view scripts will be in the
views/scripts/ subdirectory. Thus, the template
rendered will be found in
application/views/scripts/index/index.phtml.
As mentioned in the
previous section, view scripts are found in
application/views/scripts/; the view script for the
default controller and action is in
application/views/scripts/index/index.phtml. Create
this file, and type in some HTML:
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Pierwsza aplikacja Zend Framework</title>
</head>
<body>
<h1>Witaj!</h1>
</body>
</html>
Domyślnie, wtyczka
obsługi błędów jest zarejestrowana. Ta wtyczka
expects that a controller exists to handle errors.
By default, it assumes an ErrorController in the
default module with an errorAction method:
class ErrorController extends Zend_Controller_Action
{
public function errorAction()
{
}
}
Assuming the already discussed directory layout, this file will
go in application/controllers/ErrorController.php.
You will also need to create a view script in
application/views/scripts/error/error.phtml; sample
content might look like:
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Błąd</title>
</head>
<body>
<h1>Wystąpił błąd</h1>
<p>Wystąpił błąd; spróbuj ponownie później.</p>
</body>
</html>
With your first controller and view under your belt, you can now
fire up your browser and browse to the site. Assuming
example.com is your domain, any of the following
URLs will get to the page we've just created:
http://example.com/http://example.com/indexhttp://example.com/index/index
Teraz jesteś gotowy do tworzenia kolejnych kontrolerów i metod akcji. Gratulacje!