z3c.baseregistry 3.0

动机

当前组件架构的状态使我们能够

1. 创建一个全局组件注册表，使用ZCML填充它，并通过zope.component API函数使用它。

2. 定义本地站点（本地组件注册表），用本地（持久）组件填充它们，并根据位置选择性地使用它们——通常由URL路径定义。

然而，不幸的是，使用ZCML填充本地站点是不可能的。主要原因是在初始启动过程中无法对本地站点进行寻址。

然而，另一方面，我们有一个非常先进的UI配置系统，包括视图、资源、层和皮肤。让我们比较一下这两者。

1. UI中的视图/资源类似于组件架构中注册的组件。

2. UI中的皮肤层行为与注册表非常相似。默认皮肤就像全局基础注册表。皮肤，就像本地站点一样，在遍历期间被激活，但可以使用ZCML进行填充。

3. 层实际上是皮肤层的基层。在组件架构中，这相当于为组件注册表指定基础，这是由于2006年Zope 3.3的大组件架构重构所实现的。

但层可以通过ZCML进行定义和配置。此包的目的是能够创建基础组件注册表，然后使用ZCML填充它们。（顺便说一句：由于皮肤层和层实际上是相同的组件，所以全局、本地和基础组件注册表的概念之间没有区别。）

第二个功能是特定于Zope应用程序服务器的。它提供了一个UI来设置本地站点管理器上的基础。用户可以从所有已注册为IComponents实用工具的注册表中进行选择。

还有一些未来可能考虑的选项。例如，将zope:registerIn指令（请参阅下面的文档）集成到zope:configure指令中很简单。

如果上述文本对您来说太枯燥和理论化了，这里有一个总结。这个包

1. 实现了Steve Alexander（至少3年）通过ZCML定义本地站点的长期梦想。

2. 解决了我在复杂的应用程序服务提供商（ASP）设置中遇到的所有问题。

3. 实现了一个您和所有人真正想要的缺失功能，即使您现在还不知道。

感谢Jim Fulton，他杰出的zope.configuration和zope.component包的设计使得功能的实现变得如此简单。我还要感谢Fred Drake在初始设计思想上的帮助。

“基础组件”注册表

基础注册表是实现IComponents接口的全局组件注册表。与基础全局注册表（也称为globalSiteManager）相比，这些注册表不一定可以通过模块全局变量访问，必须与父注册表注册，最常见的是基础全局注册表

>>> from z3c.baseregistry import baseregistry
>>> import zope.component
>>> myRegistry = baseregistry.BaseComponents(
...     zope.component.globalSiteManager, 'myRegistry')

>>> myRegistry
<BaseComponents myRegistry>

另一个非常重要的要求是必须安装zope.component钩子。

>>> import zope.component.hooks
>>> zope.component.hooks.setHooks()

由于此注册表本身不实现任何IComponents API，因此在此处不需要展示这些功能。请参阅zope.component包中的相应文档。

全局注册表的一个特性必须是它们能够有效地pickle，因为它们可以在持久化对象中被引用。正如您所看到的，基础注册表pickle得相当好

>>> import pickle
>>> jar = pickle.dumps(myRegistry, 2)
>>> len(jar) <= 100
True

然而，当我们读取jar时，我们会得到一个错误

>>> pickle.loads(jar)
Traceback (most recent call last):
...
zope.interface.interfaces.ComponentLookupError: (<InterfaceClass zope.interface.interfaces.IComponents>, 'myRegistry')

这是因为我们还没有将其注册为其父级作为IComponents实用工具

>>> from zope.interface.interfaces import IComponents
>>> zope.component.provideUtility(myRegistry, IComponents, 'myRegistry')

>>> pickle.loads(jar)
<BaseComponents myRegistry>

因此，您始终必须将其基础注册表与其父级注册！

像任何其他组件注册表一样，基础注册表也可以有基础

>>> myOtherRegistry = baseregistry.BaseComponents(
...     zope.component.globalSiteManager, 'myRegistry', (myRegistry,))
>>> myOtherRegistry.__bases__
(<BaseComponents myRegistry>,)

现在让我们看看如何通过ZCML定义和使用基础注册表，这是通常的操作模式。

定义基础注册表

上述任务通常在ZCML中完成。基础组件注册表——或者任何IComponents实现——可以看作是提供上述接口的实用工具，并且可以通过名称区分。让我们定义一个“自定义”注册表

>>> custom = baseregistry.BaseComponents(
...     zope.component.globalSiteManager, 'custom')

让我们确保自定义注册表的父级是基础注册表

>>> custom.__parent__
<BaseGlobalComponents base>

然后使用标准实用程序指令进行注册。在加载此包的元指令后，

>>> from zope.configuration import xmlconfig
>>> from zope.configuration.config import ConfigurationConflictError
>>> context = xmlconfig.string('''
... <configure i18n_domain="zope">
...   <include package="z3c.baseregistry" file="meta.zcml" />
...   <include package="zope.component" file="meta.zcml" />
... </configure>
... ''')

我们可以注册注册表

>>> context = xmlconfig.string('''
... <configure xmlns="http://namespaces.zope.org/zope" i18n_domain="zope">
...
...   <utility
...       component="README.custom"
...       provides="zope.interface.interfaces.IComponents"
...       name="custom" />
...
... </configure>
... ''', context=context)

现在可以通过以下方式访问新的注册表

>>> custom = zope.component.getUtility(IComponents, name='custom')
>>> custom
<BaseComponents custom>

填充不同的注册表

现在来到有趣的部分。让我们为全局基本注册表和“自定义”注册表注册组件。首先，让我们创建一些可以注册的实用程序

>>> import zope.interface

>>> class IExample(zope.interface.Interface):
...     name = zope.interface.Attribute('Name of Example')

>>> @zope.interface.implementer(IExample)
... class Example(object):
...     def __init__(self, name):
...         self.name = name
...     def __repr__(self):
...         return '<%s %r>' %(self.__class__.__name__, self.name)

>>> example1 = Example('example1')
>>> example2 = Example('example2')

创建一些可以注册的适配器

>>> class IToAdapt1(zope.interface.Interface):
...     pass

>>> class IToAdapt2(zope.interface.Interface):
...     pass

>>> class IAdapted(zope.interface.Interface):
...     pass

>>> @zope.component.adapter(IToAdapt1)
... @zope.interface.implementer(IAdapted)
... def adapter1(context):
...     return "adapted1"

>>> @zope.component.adapter(IToAdapt2)
... @zope.interface.implementer(IAdapted)
... def adapter2(context):
...     return "adapted2"

>>> @zope.interface.implementer(IToAdapt1)
... class ToAdapt1(object):
...     def __init__(self, name):
...         self.name = name
...     def __repr__(self):
...         return '<%s %r>' %(self.__class__.__name__, self.name)
>>> toAdapt1 = ToAdapt1('toAdapt1')

>>> @zope.interface.implementer(IToAdapt2)
... class ToAdapt2(object):
...     def __init__(self, name):
...         self.name = name
...     def __repr__(self):
...         return '<%s %r>' %(self.__class__.__name__, self.name)
>>> toAdapt2 = ToAdapt2('toAdapt2')

现在先在全局注册表中注册“example1”，适配器1，在我们自定义注册表中注册“example2”，“adapter2”

>>> context = xmlconfig.string('''
... <configure xmlns="http://namespaces.zope.org/zope" i18n_domain="zope">
...
...   <utility component="README.example1"
...            name="example1" />
...   <adapter
...         factory="README.adapter1"
...         name="adapter1"/>
...
...   <registerIn registry="README.custom">
...     <utility component="README.example2"
...              name="example2" />
...     <adapter
...         factory="README.adapter2"
...         name="adapter2"/>
...   </registerIn>
...
... </configure>
... ''', context=context)

现在确保实用程序已正确注册到相应的注册表

>>> zope.component.getUtility(IExample, name="example1")
<Example 'example1'>

>>> zope.component.getUtility(IExample, name="example2")
Traceback (most recent call last):
...
zope.interface.interfaces.ComponentLookupError: (<InterfaceClass README.IExample>, 'example2')

现在确保适配器已正确注册到相应的注册表

>>> zope.component.getAdapter(toAdapt1, IAdapted, name="adapter1")
'adapted1'

>>> zope.component.getAdapter(toAdapt2, IAdapted, name="adapter2")
Traceback (most recent call last):
...
zope.interface.interfaces.ComponentLookupError: (<ToAdapt2 'toAdapt2'>, <InterfaceClass README.IAdapted>, 'adapter2')

>>> custom = zope.component.getUtility(IComponents, name='custom')

>>> custom.getUtility(IExample, name="example1")
Traceback (most recent call last):
...
zope.interface.interfaces.ComponentLookupError: (<InterfaceClass README.IExample>, 'example1')

>>> custom.getUtility(IExample, name="example2")
<Example 'example2'>

>>> custom.getAdapter(toAdapt1, IAdapted, name="adapter1")
Traceback (most recent call last):
...
zope.interface.interfaces.ComponentLookupError: (<ToAdapt1 'toAdapt1'>, <InterfaceClass README.IAdapted>, 'adapter1')

>>> custom.getAdapter(toAdapt2, IAdapted, name="adapter2")
'adapted2'

现在注册没有名称的Example类的其他实例。这不应该导致冲突错误

>>> example3 = Example('example3')
>>> example4 = Example('example4')

>>> context = xmlconfig.string('''
... <configure xmlns="http://namespaces.zope.org/zope" i18n_domain="zope">
...
...   <utility component="README.example3" />
...
...   <registerIn registry="README.custom">
...     <utility component="README.example4" />
...   </registerIn>
...
... </configure>
... ''', context=context)

>>> zope.component.getUtility(IExample)
<Example 'example3'>

>>> custom.getUtility(IExample)
<Example 'example4'>

使用基本注册表

通常基本注册表将用于本地站点管理器。让我们创建一个本地站点

>>> from zope.site.folder import Folder
>>> site = Folder()

>>> from zope.site.site import LocalSiteManager
>>> site.setSiteManager(LocalSiteManager(site))
>>> sm = site.getSiteManager()

最初，只有基本全局注册表是本地站点管理器的基

>>> sm.__bases__
(<BaseGlobalComponents base>,)

现在只有来自基本站点的注册表可用

>>> sm.getUtility(IExample)
<Example 'example3'>

>>> sm.getUtility(IExample, name="example1")
<Example 'example1'>

>>> sm.getUtility(IExample, name="example2")
Traceback (most recent call last):
...
zope.interface.interfaces.ComponentLookupError: (<InterfaceClass README.IExample>, 'example2')

>>> sm.getAdapter(toAdapt1, IAdapted, name="adapter1")
'adapted1'

>>> sm.getAdapter(toAdapt2, IAdapted, name="adapter2")
Traceback (most recent call last):
...
zope.interface.interfaces.ComponentLookupError: (<ToAdapt2 'toAdapt2'>, <InterfaceClass README.IAdapted>, 'adapter2')

但如果我们添加“自定义”注册表，那么事情看起来更有趣

>>> sm.__bases__ += (custom,)
>>> sm.__bases__
(<BaseGlobalComponents base>, <BaseComponents custom>)

>>> sm.getUtility(IExample)
<Example 'example3'>

>>> sm.getUtility(IExample, name="example1")
<Example 'example1'>

>>> sm.getUtility(IExample, name="example2")
<Example 'example2'>

>>> sm.getAdapter(toAdapt1, IAdapted, name="adapter1")
'adapted1'

>>> sm.getAdapter(toAdapt2, IAdapted, name="adapter2")
'adapted2'

但是示例4的注册在哪里？嗯，基的顺序很重要，就像Python中基类的顺序一样。基从最具体到最通用运行。因此，如果我们颠倒顺序，

>>> bases = list(sm.__bases__)
>>> bases.reverse()
>>> sm.__bases__ = bases
>>> sm.__bases__
(<BaseComponents custom>, <BaseGlobalComponents base>)

那么我们的“自定义”注册表实际上覆盖了全局注册表

>>> sm.getUtility(IExample)
<Example 'example4'>

>>> sm.getUtility(IExample, name="example1")
<Example 'example1'>

>>> sm.getUtility(IExample, name="example2")
<Example 'example2'>

边缘情况和思考的食物