Junya Hayashi

I'm an engineer living in Tokyo. Here I write my thoughts and experiences about software development. This is a challenge to communicate with English speakers.

[junya-hayashi-blog]

Domain Layer as a specification

Thesedays, I'm writing application using Hexagonal Architecture with python and feel that "domain layer seems to be behaving as a specification". Let me explain about that here.

Example: TagService

For explanation, let's use a simple example, "TagService".

I'll define ITagService interface on domain layer, implement it on infrastructure layer and use it on application layer. The application is writen by python, so interfaces are defined with zope.interface package (zope.interface is useful for Hexagonal Architecture in Python).

Domain Layer

from zope.interface import Interface class ITagService(Interface): # specification u""" Tag management domain service """ def add_tag(post, tag): u""" add tag to a post """ def remove_tag(post, tag): u""" remove tag from a post """

Infrastructure Layer

from zope.interface import implementer from .domain.model import ITagService @implementer(ITagService) # implement TagService as described in ITagService class TagService(object): u""" TagService using xxx """ def add_tag(self, post, tag): u""" add tag to a post """ # do some actual staff def remove_tag(self, post, tag): u""" remove tag from a post """ # do some actual staff

Application Layer

from .infrastructure import TagService def add_tag(post, tag): srv = TagService() srv.add_tag(post, tag) # use TagService as described in ITagService

The point is that ITagService defined in Domain Layer behaves as a bridge between application layer and infrastructure layer. In other words, ITagService behaves as a specification for both application and infrastructure layer.

browser implementation analogy

Let's think about these relationships using an analogy of browser implementation. (Or if you want, you can use C++ compiler implementation analogy or else instead.)

EcmaScript Specification behaves like a domain layer

Google Chrome implements EcmaScript Specification, like an infrastructure layer

Application Developer uses EcmaScript Specification, like an application layer

By defining EcmaScript specification, Chrome developer can implement features without knowing actual usage of application developers, and application developer can use JavaScript features without knowing Chrome's detailed implementation.

After I have adopted Hexagonal Architecture rather than Layered Architecture, responsibilities of each layer have been getting clearer.

[junya-hayashi-blog]

zope.interface is useful for Hexagonal Architecture in Python

When you use Hexagonal Architecture with DDD, interfaces for Repositories and Domain Services would be put on Domain layer. In such case, zope.interface is really useful for defining an interface, which helps you to write a simple code without multi-inheritance.

Here is an example.

domain layer

from abc import ABCMeta from zope.interface import Interface class Entity(object): """ Base class for Entity """ __metaclass__ = ABCMeta class IRepository(Interface): """ Interafce for Repository """ class IDomainService(Interface): """ Interface for Domain Service """ class Blog(Entity): def __init__(self, identity, title): self._identity = identity self._title = title class IBlogRepository(IRepository): """ Blog repository Interface """ def add_entity(blog): """ add blog """ def get_by(identity): """ get blog by identity """ class IBlogProvisioningService(IDomainService): """ Blog provisioning service interface """ def provision_blog(title): """ provision blog with title. returns Blog object """

infrastructure layer

import uuid from abc import ABCMeta from zope.interface import implementer from domain import Blog, IBlogRepository, IBlogProvisioningService class MySQLRepository(object): """ MySQL based repository """ __metaclass__ = ABCMeta class MemoryRepository(object): """ memory based repository """ __metaclass__ = ABCMeta @implementer(IBlogRepository) class BlogRepository(MySQLRepository): def add_entity(self, blog): # do some stuff pass def get_by(self, identity): # do some stuff return Blog(identity, "some stored title") @implementer(IBlogRepository) class BlogMemoryRepository(MemoryRepository): def add_entity(self, blog): # do some stuff pass def get_by(self, identity): # do some stuff return Blog(identity, "some stored title") @implementer(IBlogProvisioningService) class BlogProvisioningService(object): def __init__(self, repo): self._repo = repo def provision_blog(self, title): entity = Blog(uuid.uuid4().hex, title) self._repo.add_entity(entity)

test

import pytest from zope.interface.verify import verifyClass from domain import Blog, IBlogRepository, IBlogProvisioningService from infra import BlogRepository, BlogMemoryRepository, BlogProvisioningService def test_class_interface(): assert verifyClass(IBlogRepository, BlogRepository) assert verifyClass(IBlogRepository, BlogMemoryRepository) assert verifyClass(IBlogProvisioningService, BlogProvisioningService)

[junya-hayashi-blog]

Value object implementation in Python

I searched for Value object implementation in Python, and found keleshev's implementation in github. But it doesn't provide the feature of immutability of Value object. So, I implemented property based immutable Value object class by myself.

explicit property definition

value based comparison, including hash

Any feedbacks are welcome.

ValueObject class

class ValueObject(object): """ base class for Value Objects please call _set_properties in constructor. """ def __new__(class_, *args, **kwargs): self = object.__new__(class_, *args, **kwargs) self.__initialized = False self.__params = dict() return self def _set_properties(self, mapping): if self.__initialized: raise AttributeError('callable only by constructor') self.__initialized = True self.__params = dict(mapping) self.__labels = [k for k, v in mapping] def setprop(key): setattr(self.__class__, key, property(lambda x: x.__params[key])) for k, v in mapping: if not hasattr(self.__class__, k): setprop(k) def get_values(self): return self.__params def __repr__(self): return unicode(self).encode('utf-8') def __unicode__(self): return u'%s(%s)' % ( self.__class__.__name__, u', '.join(unicode(self.__params[k]) for k in self.__labels)) def __hash__(self): return hash(repr(self)) def __eq__(self, other): if not isinstance(other, self.__class__): return False return repr(self) == repr(other) def __ne__(self, other): if not isinstance(other, self.__class__): return True return repr(self) != repr(other)

Test

# -*- coding: utf-8 -*- import pytest from . import ValueObject class Date(ValueObject): def __init__(self, year, month, day): self._set_properties([ ('year', int(year)), ('month', int(month)), ('day', int(day)), ]) class Foo(ValueObject): def __init__(self, text='foo'): self._set_properties([ ('text', text), ]) @pytest.fixture def date(): return Date(2012, 2, 20) @pytest.fixture def foo_unicode(): return Foo(u'ふー') def test_properties(date): assert date.year == 2012 assert date.month == 2 assert date.day == 20 def test_immutable(date): with pytest.raises(AttributeError): date.year = 2015 def test_set_properties(date): with pytest.raises(AttributeError): date._set_properties([ ('year', 2015), ]) def test_repr(date): assert repr(date) == "Date(2012, 2, 20)" def test_get_values(date): date.get_values == {'year': 2012, 'month': 2, 'day': 20} def test_unicode(foo_unicode): assert foo_unicode.text == u'ふー' assert unicode(foo_unicode) == u"Foo(ふー)" assert repr(foo_unicode) == u"Foo(ふー)".encode('utf-8')

[junya-hayashi-blog]

Why I start this blog

I have been shared my thoughts and experiences only in Japanese, but now I feel it looses some chance to communicate with English speakers. So I decided to publish my thoughts, knowledges or experiences in this blog. Any comments and feedbacks are welcome.