This is what Maypole does. It has a number of database drivers, a number of front-end drivers, and a number of templating presentation drivers. In common cases, Maypole provides precisely what you need for all of these areas, and you get to concentrate on writing just the business logic of your application. This is one of the reasons why Maypole lets you develop so rapidly -- because most of the time, you don't need to do any development at all.

这就是Maypole所做的，他有很多的数据库驱动，很多前端驱动和很多模板表示的驱动。通常情况下，Maypole总是能够在这些领域精确的表达你的要求，你也可以专心编写应用程序的业务逻辑。这就是为什么Maypole能够让你快速开发的原因（大多数情况下你都不需要做任何开发）。

Let's begin, then, by choosing what elements are going to make up our product database. We will actually be using what is by far the most common configuration of model, view, and controller classes: Maypole provides a model class based on Class::DBI, a view class based on Template::Toolkit, and a controller class based on Apache mod_perl. We'll come to what all of this means in a second, but because this configuration is so common, it is the default; no code is required to set that up.

那么让我们开始吧，首先是挑选我们要用来实现产品数据库的技术元素。我们实际上会用目前来说最常用的模型，视图，控制的配置。 Maypole提供了一个基于Class::DBI的模型，基于Template::Toolkit的视图和基于Apache mod_perl的控制。我们会稍后介绍这些东西的具体含义，但是现在因为这个配置是如此通用，所以他是默认的配置，也不需要为了达到这个而写任何代码。

We will, however, need a database. Our client is going to be iSellIt, a fictitious supplier of computer components and software. We will have database tables for products, manufacturers, and categories of stuff, and subcategories of categories. Here's what that database might look like.

我们还需要一个数据库。我们的假想客户名字叫做iSellIt，一个计算机设备和软件供应商。我们需要有产品表，供应商表，产品目录，次分类目录。这就是数据库看起来的样子。

CREATE TABLE product (
   id int NOT NULL auto_increment primary key,
   category int,
   subcategory int,
   manufacturer int,
   part_number varchar(50),
   name varchar(50),
   cost decimal(6,2),
   description text
);

CREATE TABLE manufacturer (
   id int NOT NULL auto_increment primary key,
   name varchar(50),
   url varchar(255),
   notes text
);

CREATE TABLE category (
   id int NOT NULL auto_increment primary key,
   name varchar(50)
);

CREATE TABLE subcategory (
   id int NOT NULL auto_increment primary key,
   name varchar(50),
   category integer
);

We're going to assume that we've loaded some data into this database already, but we're going to want the sales people to update it themselves over a web interface.

我们假定数据已经被加到数据库中了，但是我们还需要销售人员可以用一个web界面来更改数据库内容。

In order to use Maypole, we need what's called a driver module. This is a very short Perl module that defines the application we're working with. I say it's a Perl module, and that may make you think this is about writing code, but to be honest, most of it is actually configuration in disguise. Here's the driver module for our ISellIt application. (The client may be called iSellIt, but many years exposure to Perl module names makes me allergic to starting one with a lowercase letter.)

为了使用Maypole，我们需要一个驱动模块。这是一段非常短的用来定义我们的应用程序的模块。我说模块可能会让你们误认为是和写代码想关的，但是实际上主要的是隐性的配置。这就是我们的ISellIt应用程序的驱动模块。（这个客户端可以叫做iSellIt，但是多年和perl模块打交道使我习惯于用小写字母打头命名）

package ISellIt;
use base 'Apache::MVC';
use Class::DBI::Loader::Relationship;

ISellIt->setup("dbi:mysql:isellit");
ISellIt->config->{uri_base} = "http://localhost/isellit";
ISellIt->config->{rows_per_page} = 10;
ISellIt->config->{loader}->relationship($_) for
 ("a manufacturer has products", "a category has products",
  "a subcategory has products", "a category has subcategories");

1;

Ten lines of code; that's the sort of size you should expect a Maypole application to be. Let's take it apart, a line at a time:

十行代码，这是你可以盼望的Maypole应用的大小。下面我们一行行地解释：

package ISellIt;

This is the name of our application, and it's what we're going to tell Apache to use as the Perl handler for our web site.

这是我们的应用程序的名字，也是我们要告诉我们web服务器上的Apache使用的Perl服务的名字。

use base 'Apache::MVC';

This says that we're using the Apache front-end to Maypole, and so we're writing a mod_perl application.

这告诉大家我们用Apache作为Maypole的前端，这样我们就可以开始写一个mod_perl的程序了。

use Class::DBI::Loader::Relationship;

Now we use a Perl module that I wrote to help put together Maypole driver classes. It allows us to declare the relationships between our database tables in a straightforward way.

现在我们用一个我编写的Perl模块来把Maypole的驱动类协调在一起。这是我们可以相当直白的描述我个的数据库中表的关系。

ISellIt->setup("dbi:mysql:isellit");

We tell ISellIt to go connect to the database and work out the tables and columns in our application. In addition, because we haven't changed any class defaults, it's assumed that we're going to use Class::DBI and Template Toolkit. We could have said that we want to use Apache::MVC with DBIx::SearchBuilder and HTML::Mason, but we don't.

我们让ISellIt连接数据库而且自己分析出表和字段的情况。并且因为我们还没有改变类的默认配置，就可以肯定的说我们会使用Class:: DBI和Template Toolkit。我们也可以说要是用Apache::MVC和DBIx::SearchBuilder和HTML::Mason，但是没说。

Maypole's Class::DBI-based class uses Class::DBI::Loader to investigate the structure of the database, and then map the product table onto a ISellIt::Product class, and so on. You can read more about how Class::DBI's table-class mapping works in Tony's article about it.

Maypole的基于Class::DBI的类使用Class::DBI::Loader来调查数据库的结构，并且把里面的产品表映射到 ISellIt::Product类，其他表的也一样。你可以在Tony的文章里面读到更多关于Class::DBI的表和类的映射的信息。

ISellIt->config->{uri_base} = "http://localhost/isellit";

ISellIt sometimes needs to know where it lives, so that it can properly produce links to other pages inside the application.

有时ISellIt也需要知道他在那个URL地址运行的，这样可以正确的在应用内部产生链接。

ISellIt->config->{rows_per_page} = 10;

This says that we don't want to display the whole product list on one page; there'll be a maximum of 10 items on a page, before we get a page-view of the list.

这行说我们不打算在一页里显示所有的产品，而是最多每页十个。

ISellIt->config->{loader}->relationship($_) for
 ("a manufacturer has products", "a category has products",
  "a subcategory has products", "a category has subcategories");

Now we define our relationship constraints, in reasonably natural syntax: a manufacturer has a number of products, and a category will delimit a collection of products, and so on.

现在我们用理想的自然语言定义关系中的约束，一个供应商有多个产品，一个分类目录有多个产品，如此类推。

Ten lines of code. What has it got us?

十行代码，这产生什么结果?

Sensible Defaults
敏感的默认行为

The second foundation of Maypole is its use of sensible defaults. It has a system of generic templates that "do the right thing" for viewing and editing data in a database. In many cases, web application programmers won't need to change the default behavior at all; in the majority of cases, they only need to change a few of the templates, and in the best cases, they can declare that the templating is the web design group's problem and not need to do any work at all.

Maypole的第二个根基是使用了敏感的默认行为。他用一个通用模板系统来很好的支持浏览和编辑库里的数据。大多数情况下，web应用都不需要改变它的默认行为。绝大多数情况下，可以稍微改掉模板的中的几个就可以。精华在于程序员可以说这是web设计组的事情然后就不用做任何工作了。

So, if we install the application and the default templates, and go to our site, http://localhost/isellit; we should see this:

好，既然我们已经把应用和默认的模板安装上去，就可以用http://localhost/isellit来登录网站。就会看到：
http://www.perl.com/2004/04/21/graphics/maypole1.png

Which is only fair for 10 lines of code. But it gets better, because if we click on, say, the product listing, we get a screen like so:

这区区十行代码就做到这么多，而且还有更精彩的，如果我们在产品列表上点击，就会去到这个屏幕：
http://www.perl.com/2004/04/21/graphics/maypole2.png
Now that's something we could probably give to the sales team with no further alterations needed, and they could happily add, edit, and delete products.

现在我们已经可以把这些给销售人员使用了，他们不用做更多的工作就可以很愉快的增添，修改，删除产品了。

Similarly, if we then click on a manufacturer in that products table, we see a handy page about the manufacturer, their products, and so on:

类似的，如果我们在产品列表中点击供应商的链接就会看到一个很乘手的关于供应商的页面。里面有他们所有的产品。还可以依此类推。
http://www.perl.com/2004/04/21/graphics/maypole3.png

Now I think we are getting some worth from our 10 lines. Next, we give the templates to the web designers. Maypole searches for templates in three different places: first, it looks for a template specific to a class; then it looks for a custom template for the whole application; finally, it looks in the factory directory to use the totally generic, do-the-right-thing template.

我想写这十行代码应该值了。然后我们让web设计人员来处理模板。Maypole在三个不同的地方搜索模板，首先看看有没有和类相关的模板，然后看看有没有应用相关的模板，最后就用模板工厂的默认的模板。

So, to make a better manufacturer view, we tell them to copy the factory/view template into manufacturer/view and customize it. We copy factory/list into product/list and customize it as a listing of products; we copy factory/header and factory/footer into the custom/ directory, and turn them into the boilerplate HTML surrounding every page, and so on.

这样的话，我们可以让他们把factory/view模板拷贝成供应商模板而且定制修改一下。我们把factory/list拷贝到 product/list定制修改一下，也把factory/header和factory/footer拷贝到custom/目录，然后把他们做成每个 HTML页面的框架，如此类推。

Now, I am not very good at HTML design, which is why I like Maypole -- it makes it someone else's problem -- but this means I'm not very good at showing you what sort of thing you can do with the templates. But here's a mock-up; I created product/view with the following template:

目前我还不怎么擅长HTML设计，这也是我喜欢Maypole的原因，它让别人来帮你解决问题，但这也意味着我没法有效的展示可以用模板做到的境界。但是有个例外，我创建了一个带有下面模板的product/view。

[% INCLUDE header %]
[% PROCESS macros %]

<DIV class="nav"> You are in: [% maybe_link_view(product.category) %] >
[% maybe_link_view(product.subcategory) %] </DIV>

<h2> [% product.name %]</h2>
<DIV class="manufacturer"> By [% maybe_link_view(product.manufacturer) %]
</DIV>
<DIV class="description"> [% product.description %] </DIV>

<TABLE class="view">
<TR>
 <TD class="field"> Price (ex. VAT) </TD>
 <TD> £ [% product.cost %] </TD>
</TR>
<TR>
 <TD class="field"> Part number </TD>
 <TD> [% product.part_number %] </TD>
</TR>
</TABLE>

[% button(product, "order") %]

Producing the following screenshot. It may not look better, but at least it proves things can be made to look different.
从下面的屏幕截图可以看到结果。他可能说不上更好，但起码证明了template可以使视觉效果有所不同。
[img]http://www.perl.com/2004/04/21/graphics/maypole4.png[/img]
We've written a Template Toolkit template; the parts surrounded in [% ... %] are templating directives. If you're not too familiar with the Template Toolkit, the Maypole manual's view documentation has a good introduction to TT in the Maypole context.
我们已经写了一个Template Toolkit的模板，在[% ... %]之间的部分是模板的打头标致。如果你不熟悉Template Toolkit，Maypole手册的视图部分是个好的简介（在Maypole中用TT）。
Maypole provides a number of default Template macros, such as maybe_link_view, which links an object to a page viewing that object, although all of these can be overridden. It also passes in the object product, which it knows to be the one we're talking about.
Maypole支持一些默认的Template宏，比如maybe_link_view，这个宏把对象和页面链接起来，当然所有这些也都可以覆盖。这个宏还参与到对象的产生过程，也就是它知道我们正在输出的信息是普通信息还是对象（若是对象就产生链接）。
In fact, that's what Maypole is really about: we've described it in terms of putting a web front-end onto a database, but fundamentally, it's responsible for using the URL /product/view/210 to load up the product object with ID 210, call the view method on its class, and pass it to the view template. Similarly, /product/list calls the list method on the product class, which populates the template with a page full of products.

实际上，这就是Maypole的核心，我们虽然主要说的是为数据库产生web界面，但是实际上他也可以为 /product/view/210这样的URL提供读出产品编号为210的服务（调用相应的显示方法并套上模板）。以此类推， /product/list调用产品类的list方法，并为所产生的一页产品列表套用模板。
The interesting thing about this template is that very last line:
这个模板有趣的地方就是最后一行：

[% button(product, "order") %]

This produces a button which will produce a POST to the URL /product/order/210, which does the same as view except this time calls the order method. But Maypole doesn't yet know how to order a product. This is OK, because we can tell it.

这就产生了一个链接到/product/order/210这个URL的调用，这和视图所做的类似，区别只在于调用的方法是order。Maypole虽然不知道如何订购一个产品，但是我们可以告诉它。

Ease of Extensibility
易于扩展


Maypole's third principle is ease of extensibility. That is to say, Maypole makes it very easy to go from a simple database front-end to a full-fledged web application. Which is just as well; as has been simulated above, once the templates come back from the web designers, you find that what you thought was just going to be a product database has become an online shop. And you've still got a deadline.

Maypole的第三个原则是易于扩展。也就是说Maypole使得为数据库提供一个羽翼丰满的web界面非常容易。但是有可能在web设计人员做好了模板以后，需求从产品数据库变成了网上商店，你又回到了最后期限的烦恼中。

But before we start extending our catalogue application to take on the new specifications (which we'll do in the second article about this), let's take a look at what we've achieved so far and what we need immediately.

但是在我们开始把这个产品目录应用程序扩展以完成新的需求之前（我们会有另外一篇文章描述这个），我们看看目前为止我们已经做到了什么和需要立即增加什么。

We've got a way to list all the products, manufacturers, categories, and subcategories in our database; we have a way to add, edit and delete all of these things; we can search for products by manufacturer, price, and so on. What's to stop us deploying this as a customer-facing web site, as well as for Intranet updates to the product catalogue?
我们有个为数据库中产品，供应商，分类和子类提供列表的方法，也可以增加，修改，删除所有的东西。还可以搜索供应商提供的产品的价格等等。阻挠我们把这个应用安装在web上或者Intranet上的东西是什么呢？
The immediate problem is security. We can add, edit, and delete products -- but so can anyone else. We want to allow those coming from the outside world only to view, list and search; for everything else, we require the user to be coming from an IP address in our internal range. (For now; we'll add the concept of a user when we're adding the shopping cart, and the idea of privileged user won't be far off that.)
最明显的问题就是安全性了，我们可以增／删／改所有产品，可是其他的任何人也可以。我们需要允许外网的人自能看和查找，对内网受限的IP地址范围的人才提供所有的服务。（现在因为需要购物车，我们有了用户的概念，特权用户的概念也很接近了）
Unfortunately, now we want some user-defined behavior, we have to start writing code. Thankfully, we don't have to write much of it. We add a few lines to our driver class, first to define our private IP address space as a NetAddr::IP object, since that provides a handy way of determining if an address is in a network:
不幸的是，现在我们有了一个用户定制的行为，所以必须开始写代码了，好在不会很多代码。我们在驱动类里面增加几行，首先是为了设置授权用户的IP地址范围，这可以用NetAddr::IP来实现。这个类提供了判断地址是否位于某个范围的乘手的方法。

use constant INTERNAL_RANGE => "10.0.0.0/8";
use NetAddr::IP;
my $range = NetAddr::IP->new(INTERNAL_RANGE);

Now we write our authentication method; Maypole's default authenticate allows everyone access to everything, so we need to override this.
下面我们来编写客户鉴权方法，Maypole的默认鉴权方法允许每个人使用每样功能，我们需要重新定义。

use Maypole::Constants;
sub authenticate {
 my ($self, $r) = @_;
 # Everyone can view, search, list
 return OK if $r->action =~ /^(view|search|list)$/;
 # Else they have to be in the internal network
 my $ip = NetAddr->IP->new($r->{ar}->connection->remote_ip);
 return OK if $ip->within($range);
 return DECLINED;
}

The authenticate class method gets passed a Maypole request object; this is like an Apache request object, but at a much, much higher level -- it contains information about the web request, the class that's going to be used to fulfill the request, the method we need to call on the class, the template that's going to be processed, any objects, form parameters, and query parameters, and so on.
这个鉴权方法过滤一个Maypole请求对象，有点像Apache的request对象，但是更加高级点（包含一个web请求的类所提供的信息和可调用方法，还有待处理的模板和form参数，以及查询参数等等）。
At this point, Maypole has already parsed the URI into its component database table, action, and additional arguments, so we first check to see if the action is one of the universally permitted ones.
在此Maypole已经把URI转化成行为，相关的表，和额外的参数。这样我们就可以判断这个行为是不是每个人都许可的。
If not, we extract the Apache::Request object stashed inside the Maypole object, and ask it for the remote IP address. If it's in the private range, we can do everything. If not, we can do nothing. Simple enough.
若不是人人许可的行为，我们就拿出内嵌的Apache::Request对象并且看看他的远端地址。如果是在许可范围的，就允许他所有的操作，否则拒绝，就是这么简单。
It's almost ready to go live, when the design guys tell you that they'd really love to put a picture alongside the description of a product. No problem.
就在万事具备的时候，设计人员让你在产品描述里增加一个图片信息，没问题。
There's two ways to do this; the way that seems really easy uses the file system to store the pictures, and has you put something like this in the template:
有两个方法可用，看上去比较容易的方案是用文件系统来存储图片，并用模板来增加图片链接。
But while that's very simple for viewing pictures, and makes a great mockup, it's not that easy to upload pictures. So you decide to put the pictures in the database. You add a "picture" binary column to the product table, and then you consult the Maypole manual.
这虽然使得看图片变得非常容易，但也有把事情弄糟的时候，因为上传图片并不容易。这就使你决定要用数据库在存储图片。在产品表里面增加一个picture的二进制列，然后你就开始看Maypole的手册。
One of the great things about this Perl Foundation sponsorship is that it's allowing me to put together a really great manual, which contains all sorts of tricks for dealing with Maypole; the Request chapter contains a couple of recipes for uploading and displaying photos.
Maypole项目是Perl基金会赞助的这件事的好处在于我可以写很好的手册，这里面有使用Maypole的每个技巧。Request这个章节有不少上传和显示图片的秘笈。
What we need to do is create some new actions -- one to upload a picture, and one to display it again. We'll only show the one to display a picture, since you can get them both from the manual, and because looking at this turns out to be a handy way to understand how to extend Maypole more generally.
目前我们需要几个动作，一是上传，一是显示。我们下面只做这些因为你不但可以看手册，而且这些就足够你很简单的了解如何更进一步的扩展Maypole。
It's useful to visualize what we're going to end up with, and work backwards. We'll have a URL like /product/view_picture/210 producing an image/png or similar page with the product's image. This allows us to put in our templates:
最好是先让大家看到我们要做的结果再反过来解释如何做。我们的/product/view_picture/210这个URL会产生一个带有image/png的页面来展示产品。这也使我们可以在模板中加入如下的：
And have the image displayed on our product view page. In fact, we're more likely to want to say:
这就可以实现显示产品图片的功能。实际上我们可能更倾向于这样写：

[% IF product.picture %]
[% ELSE %]
[% END %]

Now, we've explained that Maypole turns URLs into method calls, so we're going to be putting a view_picture method in the product's class; this class is ISellIt::Product, so we begin like this:
这样我们就向大家解释了如何使Maypole把URL转换成对象的方法调用，接着我们就要对产品类增加view_picture方法，类的名字是ISellIt::Product，我们用下面的代码开始：

package ISellIt::Product;
sub view_picture {
   my ($self, $r) = @_;
   # ...
}

This has a big problem. We don't actually want people to be able to call any method on our class over the web; that would be unwise. Maypole will refuse to do this. So in order to tell Maypole that we're allowed to call this method remotely, we decorate it with an attribute:
这还有个大问题，我们不希望外网的任何人都可以调用类的任何方法，那不太好。让Maypole来拒绝这个，为了告诉Maypole我们有权远程调用这个方法，我们用属性来修饰它：

sub view_picture :Exported {
   my ($self, $r) = @_;
}

At this point, we can call view_picture over the Web; we now need to make it populate the Maypole request with the appropriate data:
在此我们既然希望允许从外网调用view_picture，就需要用合适的数据来填充Maypole请求。

sub view_picture :Exported {
   my ($self, $r, $product) = @_;
   if ($product) {
     $r->{content_type} = "image/png";
     $r->{content} = $product->picture;
   }
}

This is a slightly unusual Maypole method, because we're bypassing the whole view class processing and templating stages, and generating content manually, but it serves to illustrate one thing: Maypole arranges for the appropriate object to be passed into the method; we've gone from URL to object without requiring any code of our own.
这是一个不太寻常的Maypole方法，因为我们跳过了类的处理和套用模板的过程，直接手工产生结果。但这也有效的显明一件事：Maypole为方法调用而维护相应的对象，帮助我们直接从URL跳到对象，不用写程序。
When we come to implementing ordering, in our next article, we'll be adding more actions like this to place the product in a user's shopping cart, check out, validate his credit card and so on. But this should be good enough for now: a templated, web-editable product database, with pictures, without stress, without too much code, and within the deadline. Well, almost.
在下篇文章我们将实现订单，我们得为产品增加更多的行为例如加到购物车，结帐，检查信用卡有效等等。但目前这就足够了：一个基于模板的，网上编辑产品数据库，还带图片的系统。没什么压力也没几行代码，还在期限内就完成了。几乎完美了。
SummaryMaypole is evolving rapidly, thanks primarily to the Perl Foundation who have enabled me to work on it for this month; it's allowed me to write many thousands of words of articles, sample applications, and Maypole-related code, and this has helped Maypole to become an extremely useful framework for developing web applications.
感谢Perl基金会的的帮助，Maypole正在快速发展。基金会不但使Maypole有可能出现，也使我有机会写几千字的文档和例子，以及和Maypole相关的代码。这些都使得Maypole成为一个非常有效的web应用框架。

建议有时间保证的人加入 ： http://www.perlchina.net/

下面引用由路杨在 2005/1/14 10:51pm 发表的内容：
建议有时间保证的人加入 ： http://www.perlchina.net/

已经跟Team1的人联系呢
寒假可以帮忙翻译N篇出来
木头加入否？

下面引用由曾子程在 2005/1/14 11:33pm 发表的内容：
已经跟Team1的人联系呢
寒假可以帮忙翻译N篇出来
木头加入否？

我没有假期。你们加油吧：）

下面引用由路杨在 2005/1/15 04:46am 发表的内容：
我没有假期。你们加油吧：）

我看你好像天天在放假哦……………………………………

下面引用由曾子程在 2005/1/15 06:10pm 发表的内容：
我看你好像天天在放假哦……………………………………

晕。。 :em06: