Catalyst::Manual::Intro - Introduction to Catalyst |
Catalyst::Manual::Intro - Introduction to Catalyst
This is a brief introduction to Catalyst. It explains the most important features of how Catalyst works and shows how to get a simple application up and running quickly. For an introduction (without code) to Catalyst itself, and why you should be using it, see the Catalyst::Manual::About manpage.
Catalyst is an elegant web application framework, extremely flexible yet extremely simple. It's similar to Ruby on Rails, Spring (Java), and Maypole, upon which it was originally based.
Catalyst follows the Model-View-Controller (MVC) design pattern, allowing you to easily separate concerns, like content, presentation, and flow control, into separate modules. This separation allows you to modify code that handles one concern without affecting code that handles the others. Catalyst promotes the re-use of existing Perl modules that already handle common web application concerns well.
Here's how the M, V, and C map to those concerns, with examples of well-known Perl modules you may want to use for each.
If you're unfamiliar with MVC and design patterns, you may want to check out the original book on the subject, Design Patterns, by Gamma, Helm, Johnson, and Vlissides, also known as the Gang of Four (GoF). Many, many web application frameworks are based on MVC, including all those listed above.
Catalyst is much more flexible than many other frameworks. We'll talk more about this later, but rest assured you can use your favorite Perl modules with Catalyst.
With Catalyst you register your actions and address them directly. For example:
sub hello : Global { my ( $self, $context ) = @_; $context->response->body('Hello World!'); }
Now http://localhost:3000/hello prints ``Hello World!''.
The best part is that Catalyst implements all this flexibility in a very simple way.
use
all of your components. Catalyst automatically finds
and loads them.
Here's how to install Catalyst and get a simple application up and running, using the helper scripts described above.
$ perl -MCPAN -e 'install Task::Catalyst'
$ catalyst.pl MyApp # output omitted $ cd MyApp $ script/myapp_create.pl controller Library::Login
$ script/myapp_server.pl
Now visit these locations with your favorite browser or user agent to see Catalyst in action:
Easy!
Let's see how Catalyst works, by taking a closer look at the components and other parts of a Catalyst application.
In addition to the Model, View, and Controller components, there's a single class that represents your application itself. This is where you configure your application, load plugins, define application-wide actions, and extend Catalyst.
package MyApp;
use strict; use Catalyst qw/-Debug/;
MyApp->config( name => 'My Application',
# You can put anything else you want in here: my_configuration_variable => 'something', );
sub default : Private { my ( $self, $context ) = @_; $context->response->body('Catalyst rocks!'); }
1;
For most applications, Catalyst requires you to define only one config parameter:
Optionally, you can specify a root parameter for templates and static
data. If omitted, Catalyst will try to auto-detect the directory's
location. You can define as many parameters as you want for plugins or
whatever you need. You can access them anywhere in your application via
$context->config->{$param_name}
.
Catalyst automatically blesses a Context object into your application class and makes it available everywhere in your application. Use the Context to directly interact with Catalyst and glue your Components together. For example, if you need to use the Context from within a Template Toolkit template, it's already there:
<h1>Welcome to [% c.config.name %]!</h1>
As illustrated in our URL-to-Action dispatching example, the Context is
always the second method parameter, behind the Component object
reference or class name itself. Previously we called it $context
for
clarity, but most Catalyst developers just call it $c
:
sub hello : Global { my ( $self, $c ) = @_; $c->res->body('Hello World!'); }
The Context contains several important objects:
$c->request $c->req # alias
The request object contains all kinds of request-specific information, like query parameters, cookies, uploads, headers, and more.
$c->req->params->{foo}; $c->req->cookies->{sessionid}; $c->req->headers->content_type; $c->req->base;
$c->response $c->res # alias
The response is like the request, but contains just response-specific information.
$c->res->body('Hello World'); $c->res->status(404); $c->res->redirect('http://oook.de');
$c->config $c->config->root; $c->config->name;
$c->log $c->log->debug('Something happened'); $c->log->info('Something you should know');
$c->stash $c->stash->{foo} = 'bar';
The last of these, the stash, is a universal hash for sharing data among application components. For an example, we return to our 'hello' action:
sub hello : Global { my ( $self, $c ) = @_; $c->stash->{message} = 'Hello World!'; $c->forward('show_message'); }
sub show_message : Private { my ( $self, $c ) = @_; $c->res->body( $c->stash->{message} ); }
Note that the stash should be used only for passing data in an individual request cycle; it gets cleared at a new request. If you need to maintain more persistent data, use a session.
A Catalyst controller is defined by its actions. An action is a subroutine with a special attribute. You've already seen some examples of actions in this document. The URL (for example http://localhost.3000/foo/bar) consists of two parts, the base (http://localhost:3000/ in this example) and the path (foo/bar). Please note that the trailing slash after the hostname[:port] always belongs to base and not to the action.
Catalyst supports several types of actions:
package MyApp::Controller::My::Controller; sub bar : Path('foo/bar') { }
Literal Path
actions will act relative to their current
namespace. The above example matches only
http://localhost:3000/my/controller/foo/bar. If you start your path with
a forward slash, it will match from the root. Example:
package MyApp::Controller::My::Controller; sub bar : Path('/foo/bar') { }
Matches only http://localhost:3000/foo/bar.
package MyApp::Controller::My::Controller; sub bar : Path { }
By leaving the Path
definition empty, it will match on the namespace
root. The above code matches http://localhost:3000/my/controller.
sub bar : Regex('^item(\d+)/order(\d+)$') { }
Matches any URL that matches the pattern in the action key, e.g. http://localhost:3000/item23/order42. The '' around the regexp is optional, but perltidy likes it. :)
Regex matches act globally, i.e. without reference to the namespace from
which it is called, so that a bar
method in the
MyApp::Controller::Catalog::Order::Process
namespace won't match any
form of bar
, Catalog
, Order
, or Process
unless you
explicitly put this in the regex. To achieve the above, you should
consider using a LocalRegex
action.
sub bar : LocalRegex('^widget(\d+)$') { }
LocalRegex actions act locally. If you were to use bar
in
MyApp::Controller::Catalog
, the above example would match urls like
http://localhost:3000/catalog/widget23.
If you omit the ``^
'' from your regex, then it will match any depth
from the controller and not immediately off of the controller name. The
following example differs from the above code in that it will match
http://localhost:3000/catalog/foo/widget23 as well.
package MyApp::Controller::Catalog; sub bar : LocalRegex('widget(\d+)$') { }
For both LocalRegex and Regex actions, if you use capturing parentheses
to extract values within the matching URL, those values are available in
the $c->req->snippets
array. In the above example, ``widget23''
would capture ``23'' in the above example, and
$c->req->snippets->[0]
would be ``23''. If you want to pass
arguments at the end of your URL, you must use regex action keys. See
URL Path Handling below.
package MyApp; sub foo : Global { }
Matches http://localhost:3000/foo. The function name is mapped directly to the application base.
package MyApp::Controller::My::Controller; sub foo : Local { }
Matches http://localhost:3000/my/controller/foo.
This action type indicates that the matching URL must be prefixed with a modified form of the component's class (package) name. This modified class name excludes the parts that have a pre-defined meaning in Catalyst (``MyApp::Controller'' in the above example), replaces ``::'' with ``/'', and converts the name to lower case. See Components for a full explanation of the pre-defined meaning of Catalyst component class names.
sub foo : Private { }
Matches no URL, and cannot be executed by requesting a URL that
corresponds to the action key. Private actions can be executed only
inside a Catalyst application, by calling the forward
method:
$c->forward('foo');
See Flow Control for a full explanation of forward
. Note that, as
discussed there, when forwarding from another component, you must use
the absolute path to the method, so that a private bar
method in your
MyApp::Controller::Catalog::Order::Process
controller must, if called
from elsewhere, be reached with
$c->forward('/catalog/order/process/bar')
.
Note: After seeing these examples, you probably wonder what the point
is of defining names for regex and path actions. Every public action is
also a private one, so you have one unified way of addressing components
in your forward
s.
In response to specific application states, Catalyst will automatically call these built-in private actions in your application class:
If default
isn't acting how you would expect, look at using a
Literal Path
action (with an empty path string). The difference is
that Path
takes arguments relative from the namespace and default
always takes arguments relative from the root, regardless of what
controller it's in.
index
is much like default
except that it takes no arguments
and it is weighted slightly higher in the matching process. It is
useful as a static entry point to a controller, e.g. to have a static
welcome page. Note that it's also weighted higher than Path.
Package MyApp::Controller::Foo; sub begin : Private { } sub default : Private { } sub auto : Private { }
You can define built-in private actions within your controllers as
well. The actions will override the ones in less-specific controllers,
or your application class. In other words, for each of the three
built-in private actions, only one will be run in any request
cycle. Thus, if MyApp::Controller::Catalog::begin
exists, it will be
run in place of MyApp::begin
if you're in the catalog
namespace,
and MyApp::Controller::Catalog::Order::begin
would override this in
turn.
In addition to the normal built-in actions, you have a special action
for making chains, auto
. Such auto
actions will be run after any
begin
, but before your action is processed. Unlike the other
built-ins, auto
actions do not override each other; they will be
called in turn, starting with the application class and going through to
the most specific class. This is the reverse of the order in which
the normal built-ins override each other.
Here are some examples of the order in which the various built-ins would be called:
/foo/foo
MyApp::begin MyApp::auto MyApp::Controller::Foo::default # in the absence of MyApp::Controller::Foo::Foo MyApp::end
/foo/bar/foo
MyApp::Controller::Foo::Bar::begin MyApp::auto MyApp::Controller::Foo::auto MyApp::Controller::Foo::Bar::auto MyApp::Controller::Foo::Bar::default # for MyApp::Controller::Foo::Bar::foo MyApp::Controller::Foo::Bar::end
The auto
action is also distinguished by the fact that you can break
out of the processing chain by returning 0. If an auto
action returns
0, any remaining actions will be skipped, except for end
. So, for the
request above, if the first auto returns false, the chain would look
like this:
/foo/bar/foo
where first auto
returns
falseMyApp::Controller::Foo::Bar::begin MyApp::auto MyApp::Controller::Foo::Bar::end
An example of why one might use this is an authentication action: you
could set up a auto
action to handle authentication in your
application class (which will always be called first), and if
authentication fails, returning 0 would skip any remaining methods
for that URL.
Note: Looking at it another way, auto
actions have to return a
true value to continue processing! You can also die
in the autochain
action; in that case, the request will go straight to the finalize
stage, without processing further actions.
You can pass variable arguments as part of the URL path, separated with
forward slashes (/). If the action is a Regex or LocalRegex, the '$' anchor
must be used. For example, suppose you want to handle /foo/$bar/$baz
,
where $bar
and $baz
may vary:
sub foo : Regex('^foo$') { my ($self, $context, $bar, $baz) = @_; }
But what if you also defined actions for /foo/boo
and /foo/boo/hoo
?
sub boo : Path('foo/boo') { .. } sub hoo : Path('foo/boo/hoo') { .. }
Catalyst matches actions in most specific to least specific order:
/foo/boo/hoo /foo/boo /foo # might be /foo/bar/baz but won't be /foo/boo/hoo
So Catalyst would never mistakenly dispatch the first two URLs to the '^foo$' action.
If a Regex or LocalRegex action doesn't use the '$' anchor, the action will
still match a URL containing arguments, however the arguments won't be
available via @_
.
Parameters passed in the URL query string are handled with methods in
the the Catalyst::Request manpage class. The param
method is functionally
equivalent to the param
method of CGI.pm
and can be used in
modules that require this.
# http://localhost:3000/catalog/view/?category=hardware&page=3 my $category = $c->req->param('category'); my $current_page = $c->req->param('page') || 1;
# multiple values for single parameter name my @values = $c->req->param('scrolling_list');
# DFV requires a CGI.pm-like input hash my $results = Data::FormValidator->check($c->req->params, \%dfv_profile);
You control the application flow with the forward
method, which
accepts the key of an action to execute. This can be an action in the
same or another Catalyst controller, or a Class name, optionally
followed by a method name. After a forward
, the control flow will
return to the method from which the forward
was issued.
A forward
is similar to a method call. The main differences are that
it wraps the call in an eval
to allow exception handling; it
automatically passes along the context object ($c
or $context
);
and it allows profiling of each call (displayed in the log with
debugging enabled).
sub hello : Global { my ( $self, $c ) = @_; $c->stash->{message} = 'Hello World!'; $c->forward('check_message'); # $c is automatically included }
sub check_message : Private { my ( $self, $c ) = @_; return unless $c->stash->{message}; $c->forward('show_message'); }
sub show_message : Private { my ( $self, $c ) = @_; $c->res->body( $c->stash->{message} ); }
A forward
does not create a new request, so your request
object ($c->req
) will remain unchanged. This is a
key difference between using forward
and issuing a
redirect.
You can pass new arguments to a forward
by adding them
in an anonymous array. In this case $c->req->args
will be changed for the duration of the forward
only; upon
return, the original value of $c->req->args
will
be reset.
sub hello : Global { my ( $self, $c ) = @_; $c->stash->{message} = 'Hello World!'; $c->forward('check_message',[qw/test1/]); # now $c->req->args is back to what it was before }
sub check_message : Private { my ( $self, $c ) = @_; my $first_argument = $c->req->args->[0]; # now = 'test1' # do something... }
As you can see from these examples, you can just use the method name as long as you are referring to methods in the same controller. If you want to forward to a method in another controller, or the main application, you will have to refer to the method by absolute path.
$c->forward('/my/controller/action'); $c->forward('/default'); # calls default in main application
Here are some examples of how to forward to classes and methods.
sub hello : Global { my ( $self, $c ) = @_; $c->forward(qw/MyApp::Model::Hello say_hello/); }
sub bye : Global { my ( $self, $c ) = @_; $c->forward('MyApp::Model::Hello'); # no method: will try 'process' }
package MyApp::Model::Hello;
sub say_hello { my ( $self, $c ) = @_; $c->res->body('Hello World!'); }
sub process { my ( $self, $c ) = @_; $c->res->body('Goodbye World!'); }
Note that forward
returns to the calling action and continues
processing after the action finishes. If you want all further processing
in the calling action to stop, use detach
instead, which will execute
the detach
ed action and not return to the calling sub. In both cases,
Catalyst will automatically try to call process()
if you omit the
method.
Catalyst has an uncommonly flexible component system. You can define as many Models, Views, and Controllers as you like.
All components must inherit from the Catalyst::Base manpage, which provides a
simple class structure and some common class methods like config
and
new
(constructor).
package MyApp::Controller::Catalog;
use strict; use base 'Catalyst::Base';
__PACKAGE__->config( foo => 'bar' );
1;
You don't have to use
or otherwise register Models, Views, and
Controllers. Catalyst automatically discovers and instantiates them
when you call setup
in the main application. All you need to do is
put them in directories named for each Component type. Notice that you
can use some very terse aliases for each one.
To show how to define views, we'll use an already-existing base class for the Template Toolkit, the Catalyst::View::TT manpage. All we need to do is inherit from this class:
package MyApp::View::TT;
use strict; use base 'Catalyst::View::TT';
1;
(You can also generate this automatically by using the helper script:
script/myapp_create.pl view TT TT
where the first TT
tells the script that the name of the view should
be TT
, and the second that it should be a Template Toolkit view.)
This gives us a process()
method and we can now just do
$c->forward('MyApp::View::TT')
to render our templates. The base class
makes process()
implicit, so we don't have to say
$c->forward(qw/MyApp::View::TT process/)
.
sub hello : Global { my ( $self, $c ) = @_; $c->stash->{template} = 'hello.tt'; }
sub end : Private { my ( $self, $c ) = @_; $c->forward('MyApp::View::TT'); }
You normally render templates at the end of a request, so it's a perfect
use for the global end
action.
Also, be sure to put the template under the directory specified in
$c->config->{root}
, or you'll be forced to look at our
eyecandy debug screen. ;)
To show how to define models, again we'll use an already-existing base class, this time for the DBIx::Class manpage: the Catalyst::Model::DBIC::Schema manpage. We'll also need the DBIx::Class::Schema::Loader manpage.
But first, we need a database.
-- myapp.sql CREATE TABLE foo ( id INTEGER PRIMARY KEY, data TEXT );
CREATE TABLE bar ( id INTEGER PRIMARY KEY, foo INTEGER REFERENCES foo, data TEXT );
INSERT INTO foo (data) VALUES ('TEST!');
% sqlite /tmp/myapp.db < myapp.sql
Now we can create a DBIC::SchemaLoader component for this database.
script/myapp_create.pl model DBIC DBIC::SchemaLoader 'dbi:SQLite:/tmp/myapp.db'
the DBIx::Class::Schema::Loader manpage automatically loads table layouts and relationships. Use the stash to pass data to your templates.
We add the following to MyApp/Controller/Root.pm
sub view : Global { my ( $self, $c, $id ) = @_; $c->stash->{item} = $c->model('DBIC::Foo')->find($id); }
1; sub end : Private { my ( $self, $c ) = @_; $c->stash->{template} ||= 'index.tt'; $c->forward( $c->view('TT') ); }
We then create a new template file ``root/index.tt'' containing:
The Id's data is [% item.data %]
Models do not have to be part of your Catalyst application; you can always call an outside module that serves as your Model:
# in a Controller sub list : Local { my ( $self, $c ) = @_; $c->stash->{template} = 'list.tt'; use Some::Outside::DBIC::Module; my @records = Some::Outside::DBIC::Module->search({ artist => 'sri', }); $c->stash->{records} = \@records; }
But by using a Model that is part of your Catalyst application, you gain
several things: you don't have to use
each component, Catalyst will
find and load it automatically at compile-time; you can forward
to
the module, which can only be done to Catalyst components; and only
Catalyst components can be fetched with
$c->model('SomeModel')
.
Happily, since many people have existing Model classes that they would like to use with Catalyst (or, conversely, they want to write Catalyst models that can be used outside of Catalyst, e.g. in a cron job), it's trivial to write a simple component in Catalyst that slurps in an outside Model:
package MyApp::Model::DB; use base qw/Catalyst::Model::DBIC::Schema/; __PACKAGE__->config( schema_class => 'Some::DBIC::Schema', connect_info => ['dbi:SQLite:foo.db', '', '', {AutoCommit=>1}] ); 1;
and that's it! Now Some::DBIC::Schema
is part of your
Cat app as MyApp::Model::DB
.
Multiple controllers are a good way to separate logical domains of your application.
package MyApp::Controller::Login;
sub sign-in : Local { } sub new-password : Local { } sub sign-out : Local { }
package MyApp::Controller::Catalog;
sub view : Local { } sub list : Local { }
package MyApp::Controller::Cart;
sub add : Local { } sub update : Local { } sub order : Local { }
Catalyst has a built-in http server for testing! (Later, you can easily use a more powerful server, e.g. Apache/mod_perl, in a production environment.)
Start your application on the command line...
script/myapp_server.pl
...then visit http://localhost:3000/ in a browser to view the output.
You can also do it all from the command line:
script/myapp_test.pl http://localhost/
Have fun!
IRC:
Join #catalyst on irc.perl.org.
Mailing-lists:
http://lists.rawmode.org/mailman/listinfo/catalyst http://lists.rawmode.org/mailman/listinfo/catalyst-dev
Sebastian Riedel, sri@oook.de
David Naughton, naughton@umn.edu
Marcus Ramberg, mramberg@cpan.org
Jesse Sheidlower, jester@panix.com
Danijel Milicevic, me@danijel.de
This program is free software, you can redistribute it and/or modify it under the same terms as Perl itself.
Catalyst::Manual::Intro - Introduction to Catalyst |