资料库 – 中文知识库

Perl 编程框架实战教程 从零掌握Mojolicious与Dancer开发技巧与常见问题解决方案

—

by

admin
in

引言：为什么选择Perl Web框架？
Perl作为一种历史悠久且功能强大的脚本语言，在Web开发领域有着广泛的应用。随着现代Web应用的复杂性不断增加，使用框架来提高开发效率、保证代码质量和维护性变得至关重要。Mojolicious和Dancer是Perl生态中最受欢迎的两个Web框架，它们各有特色，适用于不同的场景。
Mojolicious是一个全栈式的Web框架，它提供了从路由、模板渲染到实时Web功能（如WebSocket）的一整套解决方案。它的设计理念是”零依赖”，这意味着你不需要安装任何额外的模块就可以开始开发。Mojolicious内置了一个非阻塞的I/O事件循环，这使得它在处理高并发请求时表现出色。
Dancer则是一个轻量级的Web框架，它的灵感来自于Ruby的Sinatra框架。Dancer的设计哲学是简洁和易用，它提供了简单直观的语法，让开发者能够快速构建Web应用。Dancer的核心非常精简，但通过插件系统可以轻松扩展功能。
选择哪个框架取决于你的项目需求。如果你需要构建一个高性能、实时交互的Web应用，Mojolicious可能是更好的选择。如果你想要快速开发一个简单的Web服务或原型，Dancer的简洁性会让你事半功倍。
第一部分：Mojolicious框架详解
1.1 Mojolicious简介与安装
Mojolicious是一个现代的Perl Web框架，它不仅支持传统的Web应用开发，还内置了对实时Web技术的支持，如WebSocket和Server-Sent Events。它的核心特性包括：
内置HTTP服务器和客户端
强大的路由系统
灵活的模板引擎
实时Web功能
丰富的插件生态系统
安装Mojolicious非常简单，因为它不依赖任何外部模块。你可以使用cpanm或cpan来安装：
# 使用cpanm安装
cpanm Mojolicious

# 或者使用cpan
cpan Mojolicious
安装完成后，你可以通过以下命令验证安装是否成功：
mojo version
1.2 创建第一个Mojolicious应用
Mojolicious提供了一个强大的脚手架工具
mojo generate
，可以帮助我们快速创建应用结构。让我们创建一个简单的”Hello World”应用：
# 创建一个新的Mojolicious应用
mojo generate app MyApp

# 进入应用目录
cd MyApp
这会生成如下的目录结构：
MyApp/
├── script/
│ └── myapp
├── lib/
│ └── MyApp.pm
├── t/
│ └── basic.t
└── public/
└── index.html
现在，让我们修改
lib/MyApp.pm
文件，添加一个简单的路由：
package MyApp;
use Mojo::Base ‘Mojolicious’;

# 应用启动时的初始化代码
sub startup {
my $self = shift;

# 设置路由
my $r = $self->routes;

# 添加一个简单的路由
$r->get(‘/’)->to(‘example#welcome’);
}

package MyApp::Controller::Example;
use Mojo::Base ‘Mojolicious::Controller’;

# 对应的控制器方法
sub welcome {
my $self = shift;

# 渲染一个简单的响应
$self->render(text => ‘Hello, Mojolicious!’);
}

1;
现在，启动内置的开发服务器：
# 启动开发服务器
./script/myapp daemon

# 或者使用morbo（自动重载）
morbo script/myapp
访问
http://localhost:3000
，你将看到”Hello, Mojolicious!“。
1.3 Mojolicious路由系统详解
Mojolicious的路由系统非常强大且灵活。它支持RESTful路由、参数捕获、正则表达式匹配等。
1.3.1 基本路由
# GET请求路由
$r->get(‘/users’)->to(‘user#list’);

# POST请求路由
$r->post(‘/users’)->to(‘user#create’);

# 任意HTTP方法
$r->any(‘/users’)->to(‘user#handle’);
1.3.2 带参数的路由
# 捕获URL中的参数
$r->get(‘/users/:id’)->to(‘user#show’);

# 在控制器中访问参数
sub show {
my $self = shift;
my $id = $self->param(‘id’);
$self->render(text => “User ID: $id”);
}
1.3.3 正则表达式路由
# 使用正则表达式限制参数格式
$r->get(‘/posts/:year/:month/:day’)
->to(‘post#show’)
->requires(year => qr/\d{4}/)
->requires(month => qr/\d{2}/)
->requires(day => qr/\d{2}/);
1.3.4 嵌套路由和资源路由
# 嵌套路由
my $users = $r->under(‘/users’);
$users->get(‘/’)->to(‘user#list’);
$users->get(‘/:id’)->to(‘user#show’);
$users->post(‘/’)->to(‘user#create’);

# RESTful资源路由
$r->resource(‘articles’);
# 这会自动生成：
# GET /articles -> article#list
# GET /articles/create -> article#create
# POST /articles -> article#store
# GET /articles/:id -> article#show
# GET /articles/:id/edit -> article#edit
# PUT /articles/:id -> article#update
# DELETE /articles/:id -> article#destroy
1.4 Mojolicious控制器和请求处理
控制器是Mojolicious应用的核心，它们处理请求并生成响应。每个控制器方法都接收一个控制器对象（通常命名为
$self
），该对象提供了访问请求、响应、会话等信息的方法。
1.4.1 访问请求数据
package MyApp::Controller::User;
use Mojo::Base ‘Mojolicious::Controller’;

sub process {
my $self = shift;

# 获取查询参数
my $name = $self->param(‘name’);
my $age = $self->param(‘age’);

# 获取POST数据
my $body = $self->req->body;

# 获取请求头
my $user_agent = $self->req->headers->user_agent;

# 获取JSON请求体
my $json = $self->req->json;

# 渲染响应
$self->render(json => {
name => $name,
age => $age,
message => “Hello, $name!”
});
}
1.4.2 会话管理
Mojolicious内置了安全的会话管理：
sub login {
my $self = shift;

# 验证用户凭据
my $username = $self->param(‘username’);
my $password = $self->param(‘password’);

if (validate_user($username, $password)) {
# 设置会话数据
$self->session(username => $username);
$self->session(logged_in => 1);

# 会话默认24小时过期，可以自定义
$self->session(expires => time + 3600); # 1小时

$self->redirect_to(‘/dashboard’);
} else {
$self->flash(error => ‘Invalid credentials’);
$self->redirect_to(‘/login’);
}
}

sub dashboard {
my $self = shift;

# 检查会话
unless ($self->session(‘logged_in’)) {
$self->redirect_to(‘/login’);
return;
}

$self->render(username => $self->session(‘username’));
}
1.4.3 文件上传处理
sub upload_file {
my $self = shift;

# 获取上传的文件
my $file = $self->param(‘file’);

if ($file && $file->filename) {
# 安全地保存文件
my $filename = $file->filename;
# 清理文件名，防止目录遍历攻击
$filename =~ s/[^a-zA-Z0-9._-]/_/g;

my $save_path = “/path/to/uploads/$filename”;

# 移动文件
$file->move_to($save_path);

$self->render(text => “File uploaded successfully: $filename”);
} else {
$self->render(text => “No file uploaded”);
}
}
1.5 Mojolicious模板系统
Mojolicious使用内置的模板引擎，支持Perl代码嵌入、继承和助手。
1.5.1 基本模板
创建
templates/example/welcome.html.ep
：



Welcome

Hello, <%= $name %>

Today is: <%= localtime %>



在控制器中渲染：
sub welcome {
my $self = shift;
$self->render(name => ‘Mojolicious User’);
}
1.5.2 模板继承
创建基础模板
templates/layouts/default.html.ep
：



<%= title %>

My Application


<%= content %>

© 2024 MyApp



创建内容模板
templates/example/dashboard.html.ep
：
% layout ‘default’, title => ‘Dashboard’;

Welcome to Dashboard

User: <%= $username %>

1.5.3 模板助手

<%= link_to 'Home' => ‘/’ %>


<%= link_to 'User Profile' => ‘/users/’ . $user_id %>


<%= form_for '/login' => (method => ‘POST’) => begin %>



<% end %>

    % foreach my $item (@items) {

  • <%= $item %>

    • % }


% if ($logged_in) {

Welcome back!

% } else {

Please log in.

% }
1.6 Mojolicious插件系统
Mojolicious的插件系统允许你扩展应用功能。常见的插件包括数据库集成、认证、配置管理等。
1.6.1 使用内置插件
package MyApp;
use Mojo::Base ‘Mojolicious’;

sub startup {
my $self = shift;

# 配置插件
$self->plugin(‘Config’);

# 路由插件
$self->plugin(‘Routes’);

# 会话插件（默认已启用）
$self->plugin(‘Session’);

# 配置插件，从文件加载配置
$self->plugin(‘Config’ => {
file => ‘conf/app.conf’
});
}
1.6.2 使用第三方插件
# 需要先安装插件
# cpanm Mojolicious::Plugin::Database

package MyApp;
use Mojo::Base ‘Mojolicious’;

sub startup {
my $self = shift;

# 数据库插件
$self->plugin(‘Database’ => {
dsn => ‘dbi:SQLite:database=myapp.db’,
username => ”,
password => ”,
options => { RaiseError => 1, AutoCommit => 1 }
});

# 认证插件
$self->plugin(‘Authentication’ => {
session_key => ‘auth_user’,
load_user => sub {
my ($self, $uid) = @_;
return $self->db->selectrow_hashref(
“SELECT * FROM users WHERE id = ?”, undef, $uid
);
},
validate_user => sub {
my ($self, $username, $password) = @_;
my $user = $self->db->selectrow_hashref(
“SELECT * FROM users WHERE username = ?”, undef, $username
);
return $user && check_password($password, $user->{password});
}
});
}
1.7 Mojolicious实时Web功能
Mojolicious内置了对WebSocket和Server-Sent Events的支持，这使得构建实时应用变得非常简单。
1.7.1 WebSocket示例
# 路由
$r->get(‘/chat’)->to(‘chat#page’);
$r->websocket(‘/chat/ws’)->to(‘chat#socket’);

# 控制器
package MyApp::Controller::Chat;
use Mojo::Base ‘Mojolicious::Controller’;

sub page {
my $self = shift;
$self->render;
}

sub socket {
my $self = shift;

# WebSocket连接建立
$self->on(message => sub {
my ($self, $msg) = @_;

# 广播消息给所有连接的客户端
$self->app->log->info(“Received: $msg”);

# 发送响应
$self->send(“Echo: $msg”);
});

# 连接关闭
$self->on(finish => sub {
my $self = shift;
$self->app->log->info(“WebSocket connection closed”);
});
}
对应的HTML模板：



WebSocket Chat





1.7.2 Server-Sent Events (SSE)
$r->get(‘/events’)->to(‘event#stream’);

package MyApp::Controller::Event;
use Mojo::Base ‘Mojolicious::Controller’;

sub stream {
my $self = shift;

# 设置SSE响应头
$self->res->headers->content_type(‘text/event-stream’);
$self->res->headers->header(‘Cache-Control’ => ‘no-cache’);

# 发送初始事件
$self->write(“data: Connected to server\n\n”);

# 定时发送事件
my $timer = Mojo::IOLoop->recurring(2 => sub {
my $time = localtime;
$self->write(“data: Server time: $time\n\n”);
});

# 连接关闭时清理定时器
$self->on(finish => sub {
Mojo::IOLoop->remove($timer);
});
}
对应的HTML客户端：



Server-Sent Events

Server Events




1.8 Mojolicious数据库集成
虽然Mojolicious本身不包含数据库抽象层，但可以轻松集成DBI和ORM模块。
1.8.1 使用DBI直接集成
package MyApp;
use Mojo::Base ‘Mojolicious’;
use DBI;

sub startup {
my $self = shift;

# 配置数据库连接
$self->helper(db => sub {
my $self = shift;

# 延迟连接，只在需要时创建
state $dbh = DBI->connect(
“dbi:SQLite:database=myapp.db”,
“”, “”,
{
RaiseError => 1,
AutoCommit => 1,
sqlite_use_immediate_transaction => 1,
}
);

return $dbh;
});
}

# 在控制器中使用
package MyApp::Controller::User;
use Mojo::Base ‘Mojolicious::Controller’;

sub list {
my $self = shift;

my $users = $self->db->selectall_arrayref(
“SELECT id, name, email FROM users”,
{ Slice => {} }
);

$self->render(users => $users);
}

sub create {
my $self = shift;

my $name = $self->param(‘name’);
my $email = $self->param(’email’);

$self->db->do(
“INSERT INTO users (name, email) VALUES (?, ?)”,
undef, $name, $email
);

$self->redirect_to(‘/users’);
}
1.8.2 使用DBIx::Class ORM
# 首先创建Schema
# lib/MyApp/Schema.pm
package MyApp::Schema;
use base ‘DBIx::Class::Schema’;

__PACKAGE__->load_namespaces;

# lib/MyApp/Schema/Result/User.pm
package MyApp::Schema::Result::User;
use base ‘DBIx::Class::Core’;

__PACKAGE__->table(‘users’);
__PACKAGE__->add_columns(
id => { data_type => ‘integer’, is_auto_increment => 1 },
name => { data_type => ‘varchar’, size => 255 },
email => { data_type => ‘varchar’, size => 255 },
);
__PACKAGE__->set_primary_key(‘id’);

# 在应用中使用
package MyApp;
use Mojo::Base ‘Mojolicious’;
use MyApp::Schema;

sub startup {
my $self = shift;

$self->helper(schema => sub {
state $schema = MyApp::Schema->connect(
“dbi:SQLite:database=myapp.db”,
“”, “”,
{ RaiseError => 1 }
);
return $schema;
});
}

# 在控制器中使用
package MyApp::Controller::User;
use Mojo::Base ‘Mojolicious::Controller’;

sub list {
my $self = shift;

my @users = $self->schema->resultset(‘User’)->all;
$self->render(users => \@users);
}

sub create {
my $self = shift;

$self->schema->resultset(‘User’)->create({
name => $self->param(‘name’),
email => $self->param(’email’),
});

$self->redirect_to(‘/users’);
}
1.9 Mojolicious测试
Mojolicious提供了强大的测试工具，可以轻松测试Web应用。
1.9.1 基本测试
# t/basic.t
use Test::More;
use Test::Mojo;
use FindBin;
use lib “$FindBin::Bin/../lib”;

use_ok ‘MyApp’;

my $t = Test::Mojo->new(‘MyApp’);

# 测试根路由
$t->get_ok(‘/’)
->status_is(200)
->content_like(qr/Hello/);

# 测试带参数的路由
$t->get_ok(‘/users/123’)
->status_is(200)
->content_like(qr/User ID: 123/);

# 测试POST请求
$t->post_ok(‘/users’ => form => {name => ‘John’, email => ‘john@example.com’})
->status_is(302)
->header_is(Location => ‘/users’);

# 测试JSON响应
$t->get_ok(‘/api/users/123’)
->status_is(200)
->json_is(‘/id’ => 123)
->json_is(‘/name’ => ‘John’);

done_testing();
1.9.2 集成测试
# t/integration.t
use Test::More;
use Test::Mojo;

my $t = Test::Mojo->new(‘MyApp’);

# 测试完整的用户流程
subtest ‘User workflow’ => sub {
# 登录
$t->post_ok(‘/login’ => form => {
username => ‘testuser’,
password => ‘testpass’
})->status_is(302);

# 访问受保护页面
$t->get_ok(‘/dashboard’)
->status_is(200)
->content_like(qr/Welcome/);

# 创建资源
$t->post_ok(‘/articles’ => form => {
title => ‘Test Article’,
content => ‘Test content’
})->status_is(302);

# 验证创建
$t->get_ok(‘/articles’)
->status_is(200)
->content_like(qr/Test Article/);
};

done_testing();
第二部分：Dancer框架详解
2.1 Dancer简介与安装
Dancer是一个轻量级的Perl Web框架，灵感来自Ruby的Sinatra。它的核心理念是简洁和易用，通过少量的代码就能构建功能完整的Web应用。
主要特点：
极简的语法
强大的插件系统
灵活的路由定义
内置模板引擎
支持多种Web服务器后端
安装Dancer：
# 安装核心框架
cpanm Dancer

# 安装常用插件
cpanm Dancer::Plugin::Database
cpanm Dancer::Plugin::Auth::Basic
cpanm Dancer::Plugin::REST
2.2 创建第一个Dancer应用
Dancer提供了两种应用模式：单文件应用和脚手架应用。
2.2.1 单文件应用
创建
app.pl
：
#!/usr/bin/env perl
use Dancer;

# 定义路由
get ‘/’ => sub {
return ‘Hello, Dancer!’;
};

get ‘/greet/:name’ => sub {
my $name = param(‘name’);
return “Hello, $name!”;
};

post ‘/echo’ => sub {
my $message = param(‘message’);
return “Echo: $message”;
};

# 启动服务器
dance;
运行：
perl app.pl
2.2.2 脚手架应用
# 创建应用结构
dancer -a MyApp

# 进入目录
cd MyApp
生成的目录结构：
MyApp/
├── bin/
│ └── app.psgi
├── config.yml
├── environments/
│ └── development.yml
├── lib/
│ └── MyApp.pm
├── t/
│ └── 001_base.t
├── views/
│ ├── index.tt
│ └── layouts/
│ └── main.tt
└── public/
└── 500.html
2.3 Dancer路由系统
Dancer的路由系统简洁而强大，支持参数、正则表达式和HTTP方法。
2.3.1 基本路由
# GET路由
get ‘/users’ => sub {
# 处理逻辑
};

# POST路由
post ‘/users’ => sub {
# 创建用户
};

# PUT路由
put ‘/users/:id’ => sub {
# 更新用户
};

# DELETE路由
delete ‘/users/:id’ => sub {
# 删除用户
};

# 任意方法
any [‘get’, ‘post’] => ‘/mixed’ => sub {
# 处理GET和POST
};

# 所有方法
any ‘/everything’ => sub {
# 处理所有HTTP方法
};
2.3.2 路由参数
# 必需参数
get ‘/users/:id’ => sub {
my $id = param(‘id’);
return “User ID: $id”;
};

# 可选参数
get ‘/search’ => sub {
my $query = param(‘query’) || ”;
my $page = param(‘page’) || 1;
return “Searching for: $query, Page: $page”;
};

# 正则表达式约束
get qr{^/users/(\d+)$} => sub {
my ($id) = splat;
return “User ID: $id”;
};

# 命名参数与正则结合
get qr{^/posts/(\d{4})/(\d{2})/(\d{2})/(.+)$} => sub {
my ($year, $month, $day, $slug) = splat;
return “Post: $year-$month-$day: $slug”;
};
2.3.3 路由前缀和资源路由
# 路由前缀
prefix ‘/api/v1’ => sub {
get ‘/users’ => sub { … };
post ‘/users’ => sub { … };
get ‘/users/:id’ => sub { … };
};

# 资源路由（需要Dancer::Plugin::REST）
use Dancer::Plugin::REST;

resource ‘users’ => {
get => sub { … }, # GET /users/:id
list => sub { … }, # GET /users
create => sub { … }, # POST /users
update => sub { … }, # PUT /users/:id
delete => sub { … }, # DELETE /users/:id
};
2.4 Dancer请求处理
Dancer提供了简洁的API来访问请求数据。
2.4.1 访问请求参数
get ‘/process’ => sub {
# 获取单个参数
my $name = param(‘name’);

# 获取所有参数
my %params = params;

# 获取查询字符串
my $query = request->query_string;

# 获取请求体
my $body = request->body;

# 获取请求方法
my $method = request->method;

# 获取请求头
my $user_agent = request->header(‘User-Agent’);

# 获取上传文件
my $file = request->upload(‘file’);
if ($file) {
$file->copy_to(“/path/to/save/” . $file->filename);
}

return “Processed: $name”;
};
2.4.2 会话管理
# 配置会话（在config.yml或代码中）
set session => ‘YAML’;
set session_dir => ‘/path/to/sessions’;
set session_expires => 3600; # 1小时

# 使用会话
get ‘/login’ => sub {
session username => param(‘username’);
session logged_in => 1;
redirect ‘/dashboard’;
};

get ‘/dashboard’ => sub {
if (session(‘logged_in’)) {
return “Welcome, ” . session(‘username’);
} else {
redirect ‘/login’;
}
};

get ‘/logout’ => sub {
session->destroy;
redirect ‘/’;
};
2.4.3 文件上传
post ‘/upload’ => sub {
my $file = request->upload(‘file’);

if ($file && $file->filename) {
# 验证文件类型
my $filename = $file->filename;
unless ($filename =~ /\.(jpg|jpeg|png|gif)$/i) {
return “Invalid file type”;
}

# 安全保存
$filename =~ s/[^a-zA-Z0-9._-]/_/g;
my $save_path = “/path/to/uploads/$filename”;

$file->copy_to($save_path);

return “File uploaded: $filename”;
}

return “No file uploaded”;
};
2.5 Dancer模板系统
Dancer默认使用Template Toolkit作为模板引擎，但也支持其他引擎。
2.5.1 配置模板引擎
# 在config.yml中
template: “template_toolkit”
engines:
template_toolkit:
start_tag: ‘[%’
end_tag: ‘%]’
include_path: ‘/path/to/templates’
2.5.2 基本模板
创建
views/index.tt
：



[% title %]

Hello, [% name %]

Today is: [% date %]



在路由中渲染：
get ‘/’ => sub {
template ‘index’ => {
title => ‘Home’,
name => ‘Dancer User’,
date => localtime,
};
};
2.5.3 模板继承
创建布局
views/layouts/main.tt
：



[% title %]

My App


[% content %]

© 2024



在内容模板中使用：
[% layout ‘main’ %]
[% title = ‘Dashboard’ %]

Welcome

User: [% username %]

2.5.4 模板助手


4.2 Dancer常见问题
4.2.1 问题：会话管理问题
症状
：会话数据丢失或无法跨进程共享。
解决方案
：
# 1. 配置正确的会话后端
# 在config.yml中
session: “YAML”
session_dir: “/var/lib/dancer_sessions”
session_expires: 3600

# 2. 对于多进程部署，使用共享存储
# 使用Redis会话
cpanm Dancer::Session::Redis

# config.yml
plugins:
Session::Redis:
server: “redis://localhost:6379”
prefix: “dancer:session:”

# 3. 会话清理
# 定期清理过期会话
# cron job
# 0 2 * * * find /var/lib/dancer_sessions -type f -mtime +1 -delete
4.2.2 问题：数据库连接池耗尽
症状
：应用在高并发时出现数据库连接错误。
解决方案
：
# 1. 使用连接池
use Dancer::Plugin::Database;
use DBIx::Connector;

# 配置连接池
my $conn = DBIx::Connector->new(
“dbi:SQLite:database=myapp.db”,
“”, “”,
{
RaiseError => 1,
AutoCommit => 1,
sqlite_use_immediate_transaction => 1,
}
);

# 在插件中使用
hook before => sub {
# 检查连接健康
unless ($conn->ping) {
$conn->reconnect;
}
};

# 2. 限制并发连接
# 在Plack中间件中
enable “Plack::Middleware::LimitRequest”,
max_conns => 100;

# 3. 使用连接池管理器
use DBI;
use ConnectionPool;

my $pool = ConnectionPool->new(
sub {
DBI->connect(“dbi:SQLite:database=myapp.db”, “”, “”, {
RaiseError => 1,
AutoCommit => 1,
});
},
10 # 最大连接数
);

get ‘/users’ => sub {
my $dbh = $pool->borrow;
my $users = $dbh->selectall_arrayref(“SELECT * FROM users”, {Slice => {}});
$pool->return($dbh);

template ‘users’ => { users => $users };
};
4.2.3 问题：插件冲突
症状
：多个插件同时使用时出现意外行为。
解决方案
：
# 1. 检查插件加载顺序
# 在app.psgi中
use Dancer;
use Dancer::Plugin::Database;
use Dancer::Plugin::Auth::Basic;

# 2. 避免命名冲突
# 使用命名空间隔离
package MyApp::Plugin::CustomAuth;
use Dancer::Plugin;

register auth_custom => sub {
# 自定义认证逻辑
};

register_plugin;

# 3. 配置隔离
# 在config.yml中明确指定插件配置
plugins:
Database:
driver: “SQLite”
database: “myapp.db”
Auth::Basic:
username: “admin”
password: “secret”
4.2.4 问题：性能调优
症状
：应用响应慢，CPU使用率高。
解决方案
：
# 1. 使用预编译模板
# 在config.yml中
engines:
template_toolkit:
COMPILE_DIR: “/tmp/tt_cache”
COMPILE_EXT: “.ttc”

# 2. 数据库查询优化
# 使用索引
# 在数据库迁移中
$dbh->do(“CREATE INDEX idx_users_email ON users(email)”);

# 3. 使用缓存
use Dancer::Plugin::Cache;

get ‘/expensive’ => sub {
cache_get ‘expensive_data’ // do {
my $data = fetch_expensive_data();
cache_set ‘expensive_data’ => $data, 300; # 5分钟
$data;
};
};

# 4. 使用Plack::Middleware::Debug优化
# 在开发环境中
enable “Debug”, panels => [qw(DBITransaction Memory Timer)];
4.3 通用问题解决方案
4.3.1 安全问题：SQL注入
解决方案
：
# Mojolicious
sub safe_query {
my $self = shift;
my $id = $self->param(‘id’);

# 使用占位符
my $user = $self->db->selectrow_hashref(
“SELECT * FROM users WHERE id = ?”,
undef, $id
);
}

# Dancer
get ‘/user/:id’ => sub {
my $id = param(‘id’);

# 使用占位符
my $sth = database->prepare(“SELECT * FROM users WHERE id = ?”);
$sth->execute($id);
my $user = $sth->fetchrow_hashref;

return to_json($user);
};
4.3.2 安全问题：XSS攻击
解决方案
：
# Mojolicious模板中自动转义
# <%= $user_input %> # 自动HTML转义

# 如果需要原始输出
<%= $user_input %> # 转义
<%== $user_input %> # 不转义（危险）

# Dancer模板中
[% user_input | html %] # 转义
[% user_input %] # 不转义（危险）
4.3.3 部署问题：生产环境配置
Mojolicious生产部署
：
# 使用 hypnotoad 部署
# 在应用中
sub startup {
my $self = shift;

# 生产环境配置
if ($self->mode eq ‘production’) {
$self->config(
hypnotoad => {
listen => [‘http://*:8080’],
workers => 4,
accepts => 1000,
keep_alive => 300,
pid_file => ‘/var/run/hypnotoad.pid’,
}
);
}
}

# 启动命令
hypnotoad script/myapp

# 或使用systemd服务
# /etc/systemd/system/myapp.service
[Unit]
Description=MyApp
After=network.target

[Service]
Type=forking
PIDFile=/var/run/hypnotoad.pid
ExecStart=/usr/bin/hypnotoad /path/to/script/myapp
ExecReload=/usr/bin/hypnotoad -s /path/to/script/myapp
ExecStop=/usr/bin/kill -TERM $MAINPID

[Install]
WantedBy=multi-user.target
Dancer生产部署
：
# 使用Starman部署
# app.psgi
use MyApp;
use Plack::Builder;

builder {
enable “ReverseProxy”;
enable “Plack::Middleware::Static”,
path => qr{^/(static|images|css|js)/},
root => ‘./’;

mount ‘/’ => dance;
};

# 启动命令
starman –workers=4 –port=8080 app.psgi

# 或使用Nginx + Starman
# nginx.conf
upstream dancer_app {
server 127.0.0.1:8080;
}

server {
listen 80;
server_name example.com;

location / {
proxy_pass http://dancer_app;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}

location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
expires 30d;
add_header Cache-Control “public, immutable”;
root /path/to/MyApp/public;
}
}
第五部分：最佳实践与进阶技巧
5.1 项目结构最佳实践
Mojolicious项目结构
：
MyApp/
├── script/
│ ├── myapp # 主应用脚本
│ └── myapp-daemon # 生产环境启动脚本
├── lib/
│ ├── MyApp.pm # 主应用类
│ ├── MyApp/
│ │ ├── Controller/
│ │ │ ├── User.pm
│ │ │ └── Article.pm
│ │ ├── Model/
│ │ │ └── User.pm
│ │ └── Helper/
│ │ └── Auth.pm
│ └── MyApp/Schema.pm # DBIx::Class schema
├── templates/
│ ├── layouts/
│ │ └── default.html.ep
│ ├── partials/
│ │ └── header.html.ep
│ └── user/
│ ├── list.html.ep
│ └── show.html.ep
├── public/
│ ├── static/
│ │ ├── css/
│ │ ├── js/
│ │ └── images/
│ └── index.html
├── t/
│ ├── basic.t
│ ├── integration/
│ │ └── user_workflow.t
│ └── unit/
│ └── controller/
│ └── user.t
├── conf/
│ ├── app.conf # 主配置
│ ├── development.conf
│ └── production.conf
├── db/
│ ├── migrations/
│ │ ├── 001_create_users.sql
│ │ └── 002_add_indexes.sql
│ └── schema.sql
└── logs/
├── app.log
└── error.log
Dancer项目结构
：
MyApp/
├── bin/
│ └── app.psgi
├── config.yml
├── environments/
│ ├── development.yml
│ └── production.yml
├── lib/
│ └── MyApp.pm
├── views/
│ ├── index.tt
│ ├── layouts/
│ │ └── main.tt
│ └── partials/
│ ├── header.tt
│ └── footer.tt
├── public/
│ ├── static/
│ │ ├── css/
│ │ ├── js/
│ │ └── images/
│ └── index.html
├── t/
│ ├── 001_base.t
│ └── 002_integration.t
├── db/
│ ├── migrations/
│ └── schema.sql
└── logs/
├── app.log
└── development.log
5.2 代码组织与模块化
Mojolicious模块化示例
：
# lib/MyApp/Controller/User.pm
package MyApp::Controller::User;
use Mojo::Base ‘Mojolicious::Controller’;

sub list {
my $self = shift;
my $page = $self->param(‘page’) || 1;
my $per_page = 20;

my $users = $self->model(‘User’)->list($page, $per_page);
$self->render(users => $users);
}

sub show {
my $self = shift;
my $id = $self->param(‘id’);

my $user = $self->model(‘User’)->find($id);
$self->render(user => $user);
}

1;

# lib/MyApp/Model/User.pm
package MyApp::Model::User;
use Mojo::Base -base;

has ‘db’;

sub list {
my ($self, $page, $per_page) = @_;
my $offset = ($page – 1) * $per_page;

return $self->db->selectall_arrayref(
“SELECT * FROM users LIMIT ? OFFSET ?”,
{ Slice => {} },
$per_page, $offset
);
}

sub find {
my ($self, $id) = @_;
return $self->db->selectrow_hashref(
“SELECT * FROM users WHERE id = ?”,
undef, $id
);
}

1;

# lib/MyApp.pm
package MyApp;
use Mojo::Base ‘Mojolicious’;

sub startup {
my $self = shift;

# 注册模型助手
$self->helper(model => sub {
my ($self, $name) = @_;
my $class = “MyApp::Model::$name”;
eval “require $class”;
die “Model $name not found: $@” if $@;
return $class->new(db => $self->db);
});

# 路由
my $r = $self->routes;
$r->get(‘/users’)->to(‘user#list’);
$r->get(‘/users/:id’)->to(‘user#show’);
}
Dancer模块化示例
：
# lib/MyApp/Controller/User.pm
package MyApp::Controller::User;
use Dancer ‘:syntax’;
use Dancer::Plugin::Database;

prefix ‘/users’ => sub {
get ‘/’ => sub {
my $page = param(‘page’) || 1;
my $per_page = 20;
my $offset = ($page – 1) * $per_page;

my $users = database->selectall_arrayref(
“SELECT * FROM users LIMIT ? OFFSET ?”,
{ Slice => {} },
$per_page, $offset
);

template ‘users/list’ => { users => $users };
};

get ‘/:id’ => sub {
my $id = param(‘id’);
my $user = database->selectrow_hashref(
“SELECT * FROM users WHERE id = ?”,
undef, $id
);

template ‘users/show’ => { user => $user };
};
};

1;

# 在主应用中加载
# lib/MyApp.pm
package MyApp;
use Dancer;
use MyApp::Controller::User;

get ‘/’ => sub {
template ‘index’;
};

dance;
5.3 性能优化技巧
Mojolicious性能优化
：
# 1. 使用Mojo::JSON::XS
use Mojo::JSON ‘encode_json’;

# 2. 数据库查询优化
sub startup {
my $self = shift;

# 预编译常用查询
$self->helper(prepared_queries => sub {
state $queries = {
user_by_id => $self->db->prepare(
“SELECT * FROM users WHERE id = ?”
),
users_list => $self->db->prepare(
“SELECT * FROM users LIMIT ? OFFSET ?”
),
};
return $queries;
});
}

# 3. 使用缓存
use Mojo::Cache;

sub startup {
my $self = shift;

$self->helper(cache => sub {
state $cache = Mojo::Cache->new(max_keys => 500);
return $cache;
});
}

# 4. 流式响应
sub large_dataset {
my $self = shift;

$self->res->headers->content_type(‘application/json’);
$self->write(‘[‘);

my $first = 1;
while (my $row = fetch_next_row()) {
$self->write(‘,’) unless $first;
$self->write(encode_json($row));
$first = 0;
}

$self->write(‘]’);
$self->finish;
}
Dancer性能优化
：
# 1. 使用预编译模板
# config.yml
engines:
template_toolkit:
COMPILE_DIR: “/tmp/tt_cache”
COMPILE_EXT: “.ttc”
STAT_TTL: 3600

# 2. 数据库连接池
use Dancer::Plugin::Database;

# 3. 使用缓存插件
use Dancer::Plugin::Cache;

get ‘/expensive’ => sub {
return cache_get(‘expensive_data’) // do {
my $data = generate_expensive_data();
cache_set(‘expensive_data’ => $data, 600);
$data;
};
};

# 4. 使用Plack中间件
# app.psgi
builder {
enable “Plack::Middleware::Cache”,
cache => CHI->new(
driver => ‘File’,
root_dir => ‘/tmp/cache’
);

enable “ReverseProxy”;

mount ‘/’ => dance;
};
5.4 测试策略
Mojolicious测试
：
# t/001_basic.t
use Test::More;
use Test::Mojo;
use FindBin;
use lib “$FindBin::Bin/../lib”;

use_ok ‘MyApp’;

my $t = Test::Mojo->new(‘MyApp’);

# 单元测试
subtest ‘Unit tests’ => sub {
# 测试模型
use_ok ‘MyApp::Model::User’;

my $model = MyApp::Model::User->new(db => $t->app->db);
isa_ok($model, ‘MyApp::Model::User’);
};

# 集成测试
subtest ‘Integration tests’ => sub {
# 测试用户CRUD
$t->get_ok(‘/users’)->status_is(200);

$t->post_ok(‘/users’ => json => {
name => ‘Test User’,
email => ‘test@example.com’
})->status_is(200)->json_is(‘/success’ => 1);

$t->get_ok(‘/users/1’)->status_is(200);

$t->put_ok(‘/users/1’ => json => {
name => ‘Updated User’
})->status_is(200);

$t->delete_ok(‘/users/1’)->status_is(200);
};

# 性能测试
subtest ‘Performance tests’ => sub {
use Benchmark qw(cmpthese);

my $results = cmpthese(100, {
‘original’ => sub {
$t->get_ok(‘/users’)->status_is(200);
},
‘cached’ => sub {
$t->get_ok(‘/users/cached’)->status_is(200);
},
});

diag(“Performance results:\n$results”);
};

done_testing();
Dancer测试
：
# t/001_basic.t
use Test::More;
use Dancer::Test;

use_ok ‘MyApp’;

# 测试路由
response_status_is [‘GET’ => ‘/’] => 200;
response_content_like [‘GET’ => ‘/’] => qr/Hello/;

# 测试JSON API
response_status_is [‘GET’ => ‘/api/users’] => 200;
response_content_is [‘GET’ => ‘/api/users’] => to_json({users => []});

# 测试表单提交
response_status_is [‘POST’ => ‘/users’ => {
name => ‘Test’,
email => ‘test@example.com’
}] => 302;

# 测试错误处理
response_status_is [‘GET’ => ‘/users/999’] => 404;

done_testing();
5.5 部署与运维
Mojolicious部署
：
# 1. 使用hypnotoad
# 在应用中配置
sub startup {
my $self = shift;

$self->config(
hypnotoad => {
listen => [‘http://*:8080’],
workers => 4,
accepts => 1000,
keep_alive => 300,
pid_file => ‘/var/run/hypnotoad.pid’,
user => ‘www-data’,
group => ‘www-data’,
}
);
}

# 启动
hypnotoad script/myapp

# 2. 使用systemd
# /etc/systemd/system/myapp.service
[Unit]
Description=MyApp Web Service
After=network.target

[Service]
Type=forking
PIDFile=/var/run/hypnotoad.pid
ExecStart=/usr/bin/hypnotoad /opt/myapp/script/myapp
ExecReload=/usr/bin/hypnotoad -s /opt/myapp/script/myapp
ExecStop=/usr/bin/kill -TERM $MAINPID
Restart=always
User=www-data
Group=www-data
Environment=MOJO_MODE=production

[Install]
WantedBy=multi-user.target

# 3. 日志轮转
# /etc/logrotate.d/myapp
/var/log/myapp/*.log {
daily
missingok
rotate 14
compress
delaycompress
notifempty
create 640 www-data www-data
sharedscripts
postrotate
systemctl reload myapp
endscript
}
Dancer部署
：
# 1. 使用Starman
# app.psgi
use MyApp;
use Plack::Builder;

builder {
enable “ReverseProxy”;
enable “Plack::Middleware::Static”,
path => qr{^/(static|images|css|js)/},
root => ‘./’;

enable “Debug”, panels => [qw(DBITransaction Memory Timer)]
if $ENV{PLACK_ENV} eq ‘development’;

mount ‘/’ => dance;
};

# 启动
starman –workers=4 –port=8080 –access-log=/var/log/myapp/access.log app.psgi

# 2. 使用Supervisor
# /etc/supervisor/conf.d/myapp.conf
[program:myapp]
command=/usr/local/bin/starman –workers=4 –port=8080 /opt/myapp/app.psgi
directory=/opt/myapp
autostart=true
autorestart=true
user=www-data
environment=PLACK_ENV=”production”
stdout_logfile=/var/log/myapp/supervisor.log
stderr_logfile=/var/log/myapp/supervisor_error.log

# 3. Nginx配置
# /etc/nginx/sites-available/myapp
upstream dancer_app {
server 127.0.0.1:8080;
}

server {
listen 80;
server_name example.com;

# 静态文件
location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
expires 30d;
add_header Cache-Control “public, immutable”;
root /opt/myapp/public;
try_files $uri @dancer;
}

# API缓存
location ~* ^/api/ {
proxy_cache myapp_cache;
proxy_cache_valid 200 5m;
proxy_pass http://dancer_app;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}

# 主应用
location / {
proxy_pass http://dancer_app;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_connect_timeout 60s;
proxy_send_timeout 60s;
proxy_read_timeout 60s;
}
}
总结
Mojolicious和Dancer都是优秀的Perl Web框架，它们各有优势，适用于不同的场景。Mojolicious适合构建高性能、实时交互的复杂应用，而Dancer则适合快速开发简单Web服务和原型。
选择框架时，需要考虑项目需求、团队熟悉度、性能要求和长期维护成本。无论选择哪个框架，良好的代码组织、充分的测试和合理的部署策略都是成功的关键。
通过本教程的学习，你应该能够：
理解两个框架的核心概念和差异
创建和配置Mojolicious和Dancer应用
实现路由、控制器、模板和数据库集成
处理常见问题和性能优化
部署和维护生产环境的应用
记住，框架只是工具，最重要的是理解Web开发的基本原理和最佳实践。持续学习和实践将帮助你成为更优秀的开发者。