在 Django 中构建 Oracle 数据库支持的 Web 应用程序

在 Django 中构建 Oracle 数据库支持的 Web 应用程序

了解如何配置 Django 以便与 Oracle 数据库交互，并使用 ORM 进行数据库连接。

作者：Yuli Vasiliev

2009 年 8 月发布

产能在软件开发环境中意味着及时完成工作的能力。开发人员经常发现自己在重复执行相同的任务，这无疑会降低其产能。这是框架能够派上用场的地方：使用适当的框架，您可以将重点放在项目需求上，而不是处理低级、棘手的实施细节。

Django 是基于 Python 的 Web 应用程序框架，最初旨在简化数据库驱动的、面向新闻的 Web 应用程序的开发。其后，它已经发展成功能完备的 Web 框架，经常用来简化数据库支持的复杂 Web 应用程序的开发。

Django 的对象关系映射器 (ORM) 位于框架的中心，介于数据模型（您在 django.db.models.Model 类之上构建的 Python 类）和基础关系数据库对象之间。定义数据模型之后，您将能够通过映射到基础数据库中的对象的 Python 对象，来创建、检索、更新以及删除数据库数据。需要强调的是，除了 PostgreSQL、MySQL 和 SQLite 之外，Django 还正式支持 Oracle 数据库，可让您使用 ORM 特性访问和操作 Oracle 数据库数据。

安装 Django

如果您尚未安装 Django，现在可以进行安装。首先，确保您已安装 Python 2.3 或更高版本。此外，请务必安装 cx_Oracle 驱动程序（针对 Oracle 的 Python DB-API 实施），以便 Python 可与 Oracle 数据库交互。有关详细信息，您可以参阅 Przemyslaw Piotrowski 撰写的另一篇 OTN 文章“为 Python Server Pages 和 Oracle 构建快速 Web 开发环境”。然后，您可以从 Django Software Foundation 网站的 Download 页面获得 Django，地址为 http://www.djangoproject.com/download/。撰写本文时，最新的正式版本为 1.1。

安装非常简单。只需解压缩已下载的程序包，将目录更改到 Django 的解压缩目录，然后运行以下命令：

python setup.py install

上述命令将启动安装过程，此过程只需几秒。确保安装成功的最简单方法是通过 Python 交互式解释器。在交互式解释器会话中，只需输入以下命令：

import django

如果一切正常，您应该不会看到错误消息。

入门

假设您已安装 Django，现在可以尝试创建您的第一个 Django 项目，并在其中创建一个应用程序。

在 Django 中，项目包括特定网站的配置和应用程序。因此，单个项目实际上可能包括多个应用程序。然而，为了简单起见，在此创建的项目只包括一个应用程序。

首先，您可能要创建一个用于存储 Django 项目的文件夹，从操作系统提示符进入此文件夹，然后发出以下命令：

django-admin.py startproject myproj 

结果，应该显示 myproj 文件夹及其内含的以下四个文件：__init__.py、manage.py、settings.py 以及 urls.py。这四个文件的每一个都在项目中起着特定作用。

• 包括 __init__.py 是为了让此目录成为 Python 程序包，以便您能够通过点符号引用项目的各部分；例如，myproj.settings。
• manage.py 表示与上述 django-admin.py 提供相同命令但旨在用于此特定项目的命令行实用程序。
• settings.py 是包含项目设置的配置文件。在此，您可以指定数据库连接信息、时区和语言代码、有关项目中所安装的应用程序的信息，以及一些其他设置。
• urls.py 又称为 URLconf，是包含将 URL 模式映射到 Python 回调函数的 Python 代码的配置文件。

您可以看到，即使 Django 项目的配置文件也是以 Python 源代码文件的形式提供。此方法被证明很有优势，因为它使您能够动态指定设置和/或从其他配置文件中导入设置。

现在您已创建项目，可以继续下一环节，在此项目内创建一个应用程序。为此，进入先前由 django-admin.py 生成的 myproj 文件夹，并发出以下命令：

manage.py startapp myapp

在 Linux 上，您可能需要发出：

chmod +x manage.py
./manage.py startapp myapp

上述命令应该生成文件夹 myapp 及其内含的以下四个文件：__init__.py、models.py、views.py 以及 tests.py。同样，__init__.py 用于使此目录成为 Python 程序包。Tests.py 可用于为应用程序构建测试套件。此外，您将使用其余的两个文件分别定义应用程序的模型和视图：

• models.py 用于包含模型（您在 django.db.models.Model 类之上构建的 Python 类），其中每个模型都映射到一个数据库表。
• views.py 用于包含视图（Python 函数），其中每个视图或者返回 HttpResponse 对象（内容将显示在所请求页面上），或者引发 HTTP 异常。

下一步是将新创建的应用程序与项目相关联。为此，您需要编辑 myproj 文件夹中的 settings.py 文件，将字符串“myproj.myapp”追加到 INSTALLED_APPS 字节组中，如下所示：

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'myproj.myapp'
)

您已完成了应用程序主干的构建。然而，在可以查看应用程序是否正常工作之前，需要执行一些额外步骤。当然，这些步骤可能会有所不同，具体取决于您希望应用程序执行的操作。例如，如果您要构建不与数据库交互的简单应用程序，则不需要将数据库信息放在 settings.py 配置文件以及设计数据模型中。但在大多数情况下，您至少需要执行以下五个步骤：

• 在 settings.py 中指定数据库信息
• 创建模型
• 创建模板
• 创建视图
• 在 urls.py 中配置 URL 模式

在继续上述步骤之前，让我们看一下 Django 应用程序的高级视图，以便您可以更好地了解 Django 中的组件如何工作。下图示意性地显示了 Django 应用程序如何工作以满足用户请求。

根据此图中的图示，工作方式如下：

1. 用户输入支持 Django 的站点的 URL 或在此站点的已加载页面上执行操作，从而将请求发送到托管此站点的 Web 服务器。
2. Django 的 URL 调度程序遍历 urls.py 文件中的 URL 模式，并选择第一个与用户请求的 URL 匹配的模式，然后调用与所发现模式相关联的视图（Python 回调函数）。
3. 视图使用数据模型获得数据库数据，然后加载指定模板（已嵌入特殊模板标记的 HTML 页面；它类似于 Java 中的 JavaServer Page），并向其传递上下文（包括映射到模板变量名称的已获得数据）。
4. 最后，视图返回由已呈现模板填充的 HttpResponse 对象，如果出现错误，则返回 HTTP 异常。

您可以看到，Django 基于将 Web 应用程序逻辑分为模型、视图和模板的概念，因此有效地将业务逻辑和展示分离开来。通常，这类似于当今许多其他 Web 框架中使用的模型-视图-控制器 (MVC) 范例。然而，在 Django 中，视图更像控制器，介于模型和模板之间。而 Django 模板更接近于 MVC 视图，因为这些模板负责使用从模型中获得的数据生成适当的用户界面。

现在您已掌握 Django 的概念，让我们继续在本部分开头启动的项目，构建一个与 Oracle 数据库交互的简单应用程序。

配置 Django 以便与 Oracle 数据库交互

您必须先告诉 Django 如何连接到数据库，才能利用 Django 的数据库相关特性。您可以通过在项目的 settings.py 配置文件中配置数据库相关设置来执行此操作。对于在上一部分开头创建的项目，您需要编辑 django-admin.py 生成的 myproj 目录中的 settings.py。

在文本编辑器中打开 settings.py 文件，并根据您的数据库编辑与数据库相关的设置。例如，您可能按如下方式编辑它们：

DATABASE_ENGINE = 'oracle' 
DATABASE_NAME = 'XE' 
DATABASE_USER = 'hr' 
DATABASE_PASSWORD = 'hr' 
DATABASE_HOST = 'localhost' 
DATABASE_PORT = '1521'

上述方式假设您在数据库中安装了 HR 演示模式并解除了锁定。然而，在实际项目中，您很可能会使用针对特定应用程序设计的自定义模式。需要注意的是，Django 可以省去您自己创建基础表的麻烦。完成数据模型的构建之后，您可以运行 manage.py syncdb 命令以自动创建数据库表 — 针对 models.py 文件中的每个数据模型创建一个数据库表。但为了简单起见，本文中的示例将使用 HR 演示模式中已经存在的表。

现在您已指示 Django 与特定 Oracle 数据库交互，可以继续构建数据模型。

与模型的对象关系映射

如前所述，Django 支持与模型的对象关系映射，其中每个模型映射到单个数据库表，并表示子类为 django.db.models.Model 标准类的 Python 类。

以下示例说明如何针对现有表定义模型。在此示例中，您将使用 HR 的 employees 表，仅针对此表的选定字段定义模型字段。在 myproj/myapp 目录中打开 models.py 文件并进行编辑，添加 employees 类，如下所示：

from django.db import models


# Create your models here.
                 
class employees(models.Model):
    employee_id = models.IntegerField(primary_key=True)
    first_name = models.CharField(max_length=20, null = True)
    last_name = models.CharField(max_length=25)
    email = models.CharField(max_length=25)
    class Meta:
         db_table = "employees"

请注意，此处使用了一些模型字段选项。通过设置 primary_key = True，可显式指定此字段是模型的主键。max_length 是 CharField 这一字符串字段所需的参数。如果将可选的 null 参数设置为 True，即表示告诉 Django 将空值作为 NULL 保存到数据库中。默认情况下，此参数设置为 False。要查看字段选项和字段类型的完整列表，您可以参阅 Django 文档中的 Model 字段参考页面。

在上述示例中，另一个需要注意的事项是类 Meta 的使用，您可以通过此类为模型提供元数据选项。在此特定示例中，您使用 db_table 选项显式指定模型要映射到的表的名称。实际上，默认情况下，Django 假设表的名称由模型类的名称和应用程序名称组成（通过下划线 (_) 符号分隔）。因此，在此特定示例中，Django 将查找名为 myapp_employees 的表。当然，db_table 并不是您可用于模型内部类 Meta 的唯一选项。您可以在 Django 文档的 Model Meta 选项页面上查看可用的 Meta 选项列表。

此处讨论的示例很简单，因为它仅显示到单个数据库表的映射。但实际上，您通常必须处理一组通过外键约束相互关联的基础数据库表。为了解决此问题，Django 提供了 ForeignKey 字段类型，可让您定义表示多对一关系的模型字段。

幸运的是，HR 演示模式仅包含一组通过外键约束相互关联的表。例如，您可能选择 departments 表（其 manager_id 字段是 employees 表中 employee_id 的外键），并定义以下模型（将其添加到 models.py 文件中）：

class departments(models.Model):
    department_id = models.IntegerField(primary_key=True)
    department_name = models.CharField(max_length=30)
    manager = models.ForeignKey(employees, null = True)
    class Meta:
         db_table = "departments"

看一下上述模型定义，您可能已经注意到，它针对外键模型字段使用名称 manager，而不是实际在 departments 表中使用的 manager_id。实际上，在模型中使用的 manager 字段引用相应的 employees 对象，而非此对象的 employee_id 字段。当外键字段名称要引用基础表中的相应列时，Django 会隐式地将 _id 追加到此名称中。然而，在某些情况下，表中外键字段的名称结尾可能不包含 _id。如果是这种情况，您可以使用外键模型字段的 db_column 参数显式指定表列名称。虽然在此特定示例中无需如此，但您可以使用以下语法在 departments 表中显式指定外键列的名称：

manager = models.ForeignKey(employees, db_column = 'manager_id', null = True)

除了上述通过 ForeignKey 定义的多对一关系之外，Django 还支持一对一和多对多关系，您可以在模型中分别通过 OneToOneField 和 ManyToManyField 字段来定义。

使用数据库抽象 API

完成模型构建之后，您可以继续下一环节，构建将使用这些模型的视图。您可以在此使用 Django 数据库抽象 API 创建、检索、更新以及删除映射到基础数据库中的对象的 Python 对象（模型）。

让我们借助在上一部分中创建的模型，创建一个将从 employees 和 departments 数据库表中获取数据的简单视图。在 myproj/myapp 目录中，打开 views.py 文件并进行编辑，如下所示：

# Create your views here.


from django.template import Context, loader
from django.http import HttpResponse
from myproj.myapp.models import employees, departments


def index(request):
    department_list = departments.objects.exclude(manager__employee_id__exact = None).order_by('manager__employee_id')
    tmpl = loader.get_template("index.html")
    cont = Context({'departments': department_list})
    return HttpResponse(tmpl.render(cont))

在此，您添加了一个简单视图（实际上是一个名为 index 的函数），它将填充部门列表 (department_list)，其中仅包括那些具有经理的部门（这意味着，必须填写基础表中的 manager_id 字段）。然后，该视图加载 index.html 模板（将在“创建表示层”部分中讨论），并向其传递 department_list 以便呈现。最后，向 Django 返回包含 HttpResponse 对象的已呈现页面。

在此，最有趣的部分是从 departments 模型中获取数据。请注意 departments 模型类的 objects 属性的用法。通过此属性，您可以访问 models.Manager 对象（不要将它与 departments 模型中定义的 manager 字段混淆）。models.Manager 对象会附加到模型对象中，提供可让您在模型的基础表中查询数据的方法。这些方法将返回一个 QuerySet 对象，其中包含以模型对象的形式检索的数据库数据。QuerySet 对象还提供一组有用的方法，允许您进一步处理返回的模型对象。需要注意的是，一些 QuerySet 方法会返回新的 QuerySet 对象，而其他方法仅对现有 QuerySet 进行求值，然后根据此求值返回一些信息。可以在 Django 文档的 QuerySet API 参考页面上找到完整的 QuerySet 方法列表。

在此讨论的示例中，models.Manager 的 exclude 方法用于将检索的 departments 对象仅限于那些具有相关 employees 对象的对象。然后，QuerySet 的 order_by 方法返回按 departments.manager.employee_id 字段排序的新 QuerySet 对象。它类似于以下 Oracle SQL 查询：

SELECT * FROM departments WHERE manager_id IS NOT NULL ORDER BY manager_id;

除了此处使用的 exclude 方法之外，您还可以通过 objects 属性调用其他三种方法来查询模型数据。清单如下：

• all — 返回包含所有从模型基础表中获取的模型对象的 QuerySet。
• filter — 返回仅包含那些与指定条件匹配的模型对象的 QuerySet。
• exclude — 返回包含与指定条件不匹配的模型对象的 QuerySet。
• get — 返回与指定条件匹配的单个模型对象。

由于 employees HR 表中的员工 ID 从 100 开始，因此在上一示例中，您可以用 filter 替代 exclude 以便使用数据填充 department_list，如下所示：

department_list = departments.objects.filter(manager__employee_id__gte = 100).order_by('manager__employee_id')

与原始版本一样，要考虑到在 departments 和 employees 模型之间定义的多对一关系（之讨论过），在此情况下，SQL 对应物可能基于 departments 表查询，如下所示：

SELECT * FROM departments WHERE manager_id >= 100 ORDER BY manager_id;

此处讨论的所有模型查询方法（all 方法除外）都采用查找参数以缩小检索模型对象的结果集。因此，在上述示例中，您结合使用以下查找参数和 filter 方法来查询 departments 对象：

manager__employee_id__gte = 100

您可能已经猜到，上述查找参数适合以下模式：field__subfield__lookuptype=value，其中参数由双下划线分隔的关键字组成。在此，manager 是引用 employees 对象的 departments 模型的字段。而 employee_id 是 employees 模型的字段。gte 是表示大于或等于的标准字段查找。可以在此示例中使用上述组合，因为 departments 和 employees 模型通过多对一关系关联。然而，当查询非相关数据时，您应使用以下模式：field__lookuptype=value。例如，为了获得 employee_id 为 100 的 employees 对象，您可以按如下方式查询 employees 模型：

emp = employees.objects.get(employee_id__exact = 100)

实际上，您可能需要发出包含复杂 select 列表和/或复杂 WHERE 子句的查询。例如，您要根据以下查询获得 employees 对象：

SELECT employees.*, (email||'@company.com') as email_address FROM employees;

您如何告诉 Django 向依赖 employees 模型的查询的 select 列表中添加另一个字段？这就是 QuerySet 方法 extra 能够派上用场的地方。

employee_list = employees.objects.all().extra(select={'email_address': "(email||'@company.com')"})

结果，Django 将自动向此处检索的每个 employees 对象添加 extra 属性 email_address。

当然，您不仅可以使用 extra 方法增强 QuerySet 隐式生成的查询的 select 列表。您还可以指定显式 WHERE 子句并向查询的 FROM 子句添加表，以及提供要绑定到 WHERE 子句中指定的相应占位符的动态参数。以下是您可以传递到 extra 方法的参数列表：

• select — 将额外字段添加到 QuerySet 隐式生成的查询的 select 列表
• where — 在 QuerySet 查询中指定显式 WHERE 子句
• tables — 在 QuerySet 查询的 from 列表中包括其他表
• order_by — 按照通过 select 或 tables 参数添加的字段对 QuerySet 进行排序
• params — 传入将安全绑定到 WHERE 子句中指定的占位符的动态参数

到目前为止，您已了解说明如何使用 Django 数据库抽象 API 查询基础数据库数据的示例。然而，除了查询之外，您还可以使用 API 创建、更新以及删除数据库数据。

以下代码段说明如何使用此处讨论的 employees 和 departments 模型在 departments 数据库表中创建新的记录：

emp = employees.objects.get(employee_id__exact=100)
new_dept = departments(department_id = 1000, department_name = 'test', manager = emp)
new_dept.save()

结果，应该在 departments 表中显示新行。需要注意的是，model.save 方法还可用于更新现有行：

dept = departments.objects.get(department_id__exact=1000)
dept.department_name = 'new name'
dept.save()

最后，要删除行，请使用 model.delete：

dept = departments.objects.get(department_id__exact=1000)
dept.delete()

事务管理

默认情况下，Django 使用自动提交事务模式。这意味着，它可立即提交通过数据更改模型方法（例如上一部分中的 model.save 和 model.delete）进行的更改。但是，您可以使用 django.db.transaction 模块提供的事务修饰程序，针对特定视图函数更改此默认行为。您具有以下三个选项：

• @transaction.autocommit（默认）
• @transaction.commit_on_success
• @transaction.commit_manually

例如，您可能指示 Django 在视图函数内使用单个事务，并在最后仅当此函数成功返回时提交，如下所示：

from django.http import HttpResponse
from myproj.myapp.models import employees, departments
from django.http import Http404
from django.db import transaction


@transaction.commit_on_success
def newdept(request, emp_id, dept_id, dept_name):
    try:
      new_dept = departments(department_id = dept_id, department_name = dept_name, manager = None)
      new_dept.save()
      emp = employees.objects.get(employee_id__exact = emp_id)
      new_dept.manager = emp
      new_dept.save()
    except employees.DoesNotExist:
      raise Http404
    return HttpResponse("The %s department record has been inserted." %dept_name)

上述 newdept 视图函数仅当成功返回时才自动提交在其内执行的所有操作。如果引发异常，则回滚所有未定更改。但是，如果您删除 newdept 视图函数前面的修饰词或者用 @transaction.autocommit 替代此修饰词，事务行为将发生更改。如果无法找到指定员工，仍将产生 HTTP 404 异常。但此时，第一个 new_dept.save 进行的更改将立即提交到数据库，产生 manager_id 字段为空的部门记录。

需要注意的是，上面列出的代码可以通过 django.shortcuts 模块中定义的 get_object_or_404 函数大大简化。修改如下所示：

...
from django.shortcuts import get_object_or_404 


@transaction.commit_on_success
def newdept(request, emp_id, dept_name, dept_id):
    new_dept = departments(department_id = dept_id, department_name = dept_name, manager = None)
    new_dept.save()
    emp = get_object_or_404(employees, employee_id__exact = emp_id)
    new_dept.manager = emp
    new_dept.save()
    return HttpResponse("The %s department record has been inserted." %dept_name )

然而，如果您已选择 commit_manually 修饰程序，则不会选择上述语法。在这种情况下，您需要分别使用 transaction.commit 或 transaction.rollback 显式提交或回滚事务。因此，try-except 语法似乎更适用于这种情况：

...
from django.db import transaction
...
@transaction.commit_manually
def newdept(request, emp_id, dept_id, dept_name):
    try:
      new_dept = departments(department_id = dept_id, department_name = dept_name, manager = None)
      new_dept.save()
      emp = employees.objects.get(employee_id__exact = emp_id)
      new_dept.manager = emp
      new_dept.save()
    except employees.DoesNotExist:
      transaction.rollback()
      raise Http404
    else:
      transaction.commit()
    return HttpResponse("The %s department record has been inserted." %dept_name)

将上述 newdept 视图添加到 myproj/myapp/views.py 中。

创建表示层

如上所述，Django 模板旨在使用 django.template.Context 对象在视图中显示传递给它们的信息。回到在前面的“使用数据库抽象 API”部分中讨论的 index 视图函数，让我们创建在此视图中使用的模板 index.html。

首先，在 myapp 目录内创建一个名为 templates 的目录。默认情况下，这是 Django 查找模板的目录。然后，在 myapp/templates 目录内创建 index.html，并将以下代码插入文件中：

Managers of departments

 
 
 
 
 
 
 
 
 
{% for department in departments %} 
 
 
 
 
 
 
 
{% endfor %} 

empid	first name	first name	email	department name
{{department.manager.employee_id}}	{{department.manager.first_name}}	{{department.manager.last_name}}	{{department.manager.email}}	{{department.department_name}}

模板中的代码非常简单。您使用标准 HTML 标记定义标题和表元素，嵌入 Django 的模板语言元素，这些语言元素的变量标记位于双花括号 {{ ..}} 中，而块标记位于 {% ..%} 对中。要了解有关 Django 模板语言的更多信息，您可以参阅 Django 文档中的“The Django template language”页面。

URL 调度

对于此处讨论的 Django 应用程序，最后一个难题是 URLconf，它应该包含传入请求与视图函数匹配的 URL 模式。虽然您可以完全在项目级别定义这些模式，但将应用程序的 URL 从项目的配置中分离出来被认为是个较好的做法。因此，按如下方式编辑 myproj 目录中的 urls.py 文件：

...
urlpatterns = patterns('',

...

    url(r'^myapp/', include('myproj.myapp.urls')),
)

然后，在 myapp 目录中创建 urls.py 文件，并将以下代码插入其中：

from django.conf.urls.defaults import * 
from myapp.views import index, newdept

urlpatterns = patterns('', 
url(r'^(?P\d+)/(?P\w+)/(?P\d+)/$' , newdept), 
url(r'^$', index), 
)

您可能已经猜到，第一种模式旨在处理向“事务管理”部分中讨论的 newdept 视图发出的请求，第二种模式用于向 index 视图发出的请求。

使用 Django 开发 Web 服务器

现在该测试您刚构建的 Django 应用程序了。为此，您可以使用 Django 的内置开发 Web 服务器。首先，从操作系统提示符进入 myproj 目录，并发出以下命令：

manage.py runserver

结果，您应该看到一些告知您开发服务器正在运行的输出行，以及此服务器所在的地址（默认情况下，应该为 http://127.0.0.1:8000/）。剩下的就是将您的浏览器指向 http://127.0.0.1:8000/myapp/。结果应该如下图所示：

要测试 newdept 视图，您可以在 Web 浏览器中输入以下 url：http://localhost:8000/myapp/100/test/1000/。这应该将新记录插入 departments 表中，此记录的 department_id 为 1000，department_name 为 test，manager_id 为 100。

将 Django 用于 Apache

Django 的内置开发 Web 服务器仅适用于测试，这意味着它并不是生产服务器。如果要将它用于生产，您需要慎重考虑。

您可以通过 mod_python 模块（用于在 Apache 内嵌入 Python）将 Django 部署到 Apache。因此，首先确保您已将 mod_python 模块安装到 Apache 服务器上（可以在 此处找到详细信息）。然后，您可以将以下 Location 块添加到 Apache 的 httpd.conf 配置文件中（在 PythonPath 中使用实际路径）：

< Location "/myapp/">
    SetHandler python-program
    PythonPath "['/home/user/myprojects', '/home/user/myprojects/myproj'] + sys.path"
    PythonHandler django.core.handlers.modpython
    SetEnv DJANGO_SETTINGS_MODULE myproj.settings
    PythonDebug On
< /Location>

重新启动 Apache 之后，您就可以测试应用程序了。如果您的 Apache 服务器在 localhost 上运行，您可以将浏览器指向 http://localhost/myapp/ 以测试 index 视图，指向 http://localhost/myapp/100/test/1000/ 以查看 newdept 是否正常工作。

结论

正如您在本文中了解的那样，Django 是一个功能强大的 Web 框架，可让您迅速创建数据库驱动的 Web 应用程序。您还可以轻而易举地将 Django 连接到 Oracle 数据库。此外，Django 还具有绝佳的 ORM 特性。