Python事件类别映射设计

Question

我正在写一些代码，用来整理我们的事件定义和类别映射。我们的目标是能够定义“事件名称”，并且关联相应的类别，这个过程基本上是固定的。我们希望大家使用常量，而不是到处都是字符串。我们还需要一个地方来验证事件和类别，并且能够进行一些查找，比如根据类别获取事件，或者反过来。

class EventMapping(object)
    def __init__(self, name, categories):
        self.name =  name
        self.categories=  categories
        EventRegistry.register(self)

    def __eq__(self, obj):
        if(isinstance(obj, str)):
            return obj==self.name
        if(isinstance(obj, EventMapping)):
            return obj.name ==self.name 
               and obj.categories==self.categories
        return False

    def __repr__(self):
        return self.name   

class Event():
    class MyCompontent():
        ComponentEvent = EventMapping("ComponentEvent", None)
        ComponentEventWCategory = EventMapping("ComponentEvent"
             , [Category.MyComponent.Useful])
    class Data():
         Created =EventMapping("Created", [Category.Data.All, Category.Data.Count]
         Updated= EventMapping("Updated", [Category.Data.All]
         Deleted= EventMapping("Deleted", [Category.Data.All, Category.Data.Count]

class Category():
    class MyComponent():
        Useful = "Useful"
    class Data():
        All= "All" 
        Count= "Count" 

class EventRegistry():
    @staticmethod
    def register( eventMapping):
        eventName= eventMapping.name
        #store locally...

    @staticmethod
    def events(category):
        #retreive events by category

    @staticmethod
    def category(event_name):
        #retreive categories by event name

有几个我不太喜欢的地方：

1. 在EventRegistry类中，我把它们存储了两次，一次是在一个事件字典里，键是名称，值是一个类别列表。第二次是在一个类别字典里，键是类别名称，值是一个事件列表。这样做有没有更好的方法呢？我基本上需要一个简单的方法来根据名称或类别进行查找。

2. 我是不是应该创建两个注册表？一个用于类别，一个用于事件？

3. 在使用事件时，我们是这样做的：

   self.subscribe(Event.MyComponent.Useful) self.subscribe(Category.MyComponent.Useful)

然后我们使用注册表来验证事件是否存在，并且发送消息。有没有更简单的方法来实现像命名空间一样的功能呢？

我只是想寻求一些反馈，看看有没有更好的方法或者可以遵循的模式。我搜索过，但找不到相关的信息。如果你知道有什么模块可以让我了解更好的做法，我也很乐意去看看。

Answer 1

你为什么不试试更符合Python风格的做法呢？

from collections import defaultdict


_linked = defaultdict(set)


class Linkable(object):

    def link(self, *others):
        _linked[self].update(others)
        for each in others:
            _linked[each].add(self)

    def unlink(self, *others):
        _linked[self].difference_update(others)
        for each in others:
            _linked[each].discard(self)

    def links(self):
        return set(_linked[self])


class NameHierarchy(object):

    def __init__(self, name, parent=None):
        self.name = name
        self.parent = parent or self
        self.path = parent.path + [self] if parent else [self]

    def __str__(self):
        return '.'.join(each.name for each in self.path)

    def add(self, name):
        if name not in self.__dict__:
            setattr(self, name, self.__class__(name, self))


class LinkedNameHierarchy(Linkable, NameHierarchy):
    pass


Category = LinkedNameHierarchy('Category')

Category.add('MyComponent')
Category.MyComponent.add('Useful')

Category.add('Data')
Category.Data.add('All')
Category.Data.add('Count')

Event = LinkedNameHierarchy('Event')

Event.add('MyComponent')
Event.MyComponent.add('ComponentEvent')
Event.MyComponent.add('ComponentEventWCategory')

Event.MyComponent.ComponentEventWCategory.link(Category.MyComponent.Useful)

Event.add('Data')
Event.Data.add('Created')
Event.Data.add('Updated')
Event.Data.add('Deleted')

Event.Data.Created.link(Category.Data.All, Category.Data.Count)
Event.Data.Updated.link(Category.Data.All)
Event.Data.Deleted.link(Category.Data.All, Category.Data.Count)


def show_links():
    print
    print '----8<--------8<--------8<--------8<--------8<--------8<----'
    for k, v in sorted(_linked.iteritems(), key=lambda x:str(x[0])):
        print
        print k
        for each in sorted(v, key=str):
            print '        ', each

show_links()

Event.Data.Created.unlink(Category.Data.Count)

show_links()

这里有循环引用，通常这会导致内存泄漏。但在这种情况下没关系，因为这些对象大概会和程序一起运行的时间一样长。